diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/ColumnsContainer.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/ColumnsContainer.kt
new file mode 100644
index 000000000..85af9ee02
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/ColumnsContainer.kt
@@ -0,0 +1,86 @@
+package org.jetbrains.kotlinx.dataframe
+
+import org.jetbrains.kotlinx.dataframe.api.ColumnSelectionDsl
+import org.jetbrains.kotlinx.dataframe.api.asColumnGroup
+import org.jetbrains.kotlinx.dataframe.api.cast
+import org.jetbrains.kotlinx.dataframe.api.castFrameColumn
+import org.jetbrains.kotlinx.dataframe.api.getColumn
+import org.jetbrains.kotlinx.dataframe.columns.ColumnGroup
+import org.jetbrains.kotlinx.dataframe.columns.ColumnPath
+import org.jetbrains.kotlinx.dataframe.columns.ColumnReference
+import org.jetbrains.kotlinx.dataframe.columns.FrameColumn
+import org.jetbrains.kotlinx.dataframe.impl.columnName
+import org.jetbrains.kotlinx.dataframe.impl.columns.asAnyFrameColumn
+import kotlin.reflect.KProperty
+
+/**
+ * Provides access to [columns][DataColumn].
+ *
+ * Base interface for [DataFrame] and [ColumnSelectionDsl]
+ *
+ * @param T Schema marker. Used to generate extension properties for typed column access.
+ */
+public interface ColumnsContainer<out T> {
+
+    // region columns
+
+    public fun columns(): List<AnyCol>
+
+    public fun columnsCount(): Int
+
+    public fun containsColumn(name: String): Boolean
+
+    public fun containsColumn(path: ColumnPath): Boolean
+
+    public fun getColumnIndex(name: String): Int
+
+    // endregion
+
+    // region getColumnOrNull
+
+    public fun getColumnOrNull(name: String): AnyCol?
+
+    public fun getColumnOrNull(index: Int): AnyCol?
+
+    public fun <R> getColumnOrNull(column: ColumnReference<R>): DataColumn<R>?
+
+    public fun <R> getColumnOrNull(column: KProperty<R>): DataColumn<R>?
+
+    public fun getColumnOrNull(path: ColumnPath): AnyCol?
+
+    public fun <R> getColumnOrNull(column: ColumnSelector<T, R>): DataColumn<R>?
+
+    // endregion
+
+    // region get
+
+    public operator fun get(columnName: String): AnyCol = getColumn(columnName)
+
+    public operator fun get(columnPath: ColumnPath): AnyCol = getColumn(columnPath)
+
+    public operator fun <R> get(column: DataColumn<R>): DataColumn<R> = getColumn(column.name()).cast()
+
+    public operator fun <R> get(column: DataColumn<DataRow<R>>): ColumnGroup<R> = getColumn(column)
+
+    public operator fun <R> get(column: DataColumn<DataFrame<R>>): FrameColumn<R> = getColumn(column)
+
+    public operator fun <R> get(column: ColumnReference<R>): DataColumn<R> = getColumn(column)
+
+    public operator fun <R> get(column: ColumnReference<DataRow<R>>): ColumnGroup<R> = getColumn(column)
+
+    public operator fun <R> get(column: ColumnReference<DataFrame<R>>): FrameColumn<R> = getColumn(column)
+
+    public operator fun <R> get(column: KProperty<R>): DataColumn<R> = get(column.columnName).cast()
+
+    public operator fun <R> get(column: KProperty<DataRow<R>>): ColumnGroup<R> =
+        get(column.columnName).asColumnGroup().cast()
+
+    public operator fun <R> get(column: KProperty<DataFrame<R>>): FrameColumn<R> =
+        get(column.columnName).asAnyFrameColumn().castFrameColumn()
+
+    public fun <C> get(columns: ColumnsSelector<T, C>): List<DataColumn<C>>
+
+    public fun <C> get(column: ColumnSelector<T, C>): DataColumn<C> = get(column as ColumnsSelector<T, C>).single()
+
+    // endregion
+}
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/DataColumn.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/DataColumn.kt
new file mode 100644
index 000000000..b61c9ae2d
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/DataColumn.kt
@@ -0,0 +1,153 @@
+package org.jetbrains.kotlinx.dataframe
+
+import org.jetbrains.kotlinx.dataframe.api.Infer
+import org.jetbrains.kotlinx.dataframe.api.asDataColumn
+import org.jetbrains.kotlinx.dataframe.api.cast
+import org.jetbrains.kotlinx.dataframe.api.concat
+import org.jetbrains.kotlinx.dataframe.api.filter
+import org.jetbrains.kotlinx.dataframe.api.map
+import org.jetbrains.kotlinx.dataframe.api.schema
+import org.jetbrains.kotlinx.dataframe.api.take
+import org.jetbrains.kotlinx.dataframe.columns.BaseColumn
+import org.jetbrains.kotlinx.dataframe.columns.ColumnGroup
+import org.jetbrains.kotlinx.dataframe.columns.ColumnKind
+import org.jetbrains.kotlinx.dataframe.columns.ColumnPath
+import org.jetbrains.kotlinx.dataframe.columns.ColumnResolutionContext
+import org.jetbrains.kotlinx.dataframe.columns.ColumnWithPath
+import org.jetbrains.kotlinx.dataframe.columns.FrameColumn
+import org.jetbrains.kotlinx.dataframe.columns.ValueColumn
+import org.jetbrains.kotlinx.dataframe.impl.columns.ColumnGroupImpl
+import org.jetbrains.kotlinx.dataframe.impl.columns.FrameColumnImpl
+import org.jetbrains.kotlinx.dataframe.impl.columns.ValueColumnImpl
+import org.jetbrains.kotlinx.dataframe.impl.columns.addPath
+import org.jetbrains.kotlinx.dataframe.impl.columns.guessColumnType
+import org.jetbrains.kotlinx.dataframe.impl.columns.toColumnKind
+import org.jetbrains.kotlinx.dataframe.impl.getValuesType
+import org.jetbrains.kotlinx.dataframe.impl.splitByIndices
+import org.jetbrains.kotlinx.dataframe.schema.DataFrameSchema
+import kotlin.reflect.KClass
+import kotlin.reflect.KProperty
+import kotlin.reflect.KType
+import kotlin.reflect.typeOf
+
+/**
+ * Column with [name] and [values] of specific [type].
+ *
+ * Base interface for [ValueColumn] and [FrameColumn], but not for [ColumnGroup]. However, implementations for all three [column kinds][ColumnKind] derive from DataColumn and can cast to it safely.
+ * Column operations that have signature clash with [DataFrame] API ([filter], [take], [map] etc.) are defined for [DataColumn] and not for [BaseColumn].
+ *
+ * @param T type of values in the column.
+ */
+public interface DataColumn<out T> : BaseColumn<T> {
+
+    public companion object {
+
+        /**
+         * Creates [ValueColumn] using given [name], [values] and [type].
+         *
+         * @param name name of the column
+         * @param values list of column values
+         * @param type type of the column
+         * @param infer column type inference mode
+         */
+        public fun <T> createValueColumn(
+            name: String,
+            values: List<T>,
+            type: KType,
+            infer: Infer = Infer.None,
+            defaultValue: T? = null,
+        ): ValueColumn<T> = ValueColumnImpl(values, name, getValuesType(values, type, infer), defaultValue)
+
+        /**
+         * Creates [ValueColumn] using given [name], [values] and reified column [type].
+         *
+         * Note, that column [type] will be defined at compile-time using [T] argument
+         *
+         * @param T type of the column
+         * @param name name of the column
+         * @param values list of column values
+         * @param infer column type inference mode
+         */
+        public inline fun <reified T> createValueColumn(
+            name: String,
+            values: List<T>,
+            infer: Infer = Infer.None,
+        ): ValueColumn<T> =
+            createValueColumn(
+                name,
+                values,
+                getValuesType(
+                    values,
+                    typeOf<T>(),
+                    infer,
+                ),
+            )
+
+        public fun <T> createColumnGroup(name: String, df: DataFrame<T>): ColumnGroup<T> = ColumnGroupImpl(name, df)
+
+        public fun <T> createFrameColumn(name: String, df: DataFrame<T>, startIndices: Iterable<Int>): FrameColumn<T> =
+            FrameColumnImpl(name, df.splitByIndices(startIndices.asSequence()).toList(), lazy { df.schema() })
+
+        public fun <T> createFrameColumn(
+            name: String,
+            groups: List<DataFrame<T>>,
+            schema: Lazy<DataFrameSchema>? = null,
+        ): FrameColumn<T> = FrameColumnImpl(name, groups, schema)
+
+        public fun <T> createWithTypeInference(
+            name: String,
+            values: List<T>,
+            nullable: Boolean? = null,
+        ): DataColumn<T> = guessColumnType(name, values, nullable = nullable)
+
+        public fun <T> create(
+            name: String,
+            values: List<T>,
+            type: KType,
+            infer: Infer = Infer.None,
+        ): DataColumn<T> =
+            when (type.toColumnKind()) {
+                ColumnKind.Value -> createValueColumn(name, values, type, infer)
+                ColumnKind.Group -> createColumnGroup(name, (values as List<AnyRow?>).concat()).asDataColumn().cast()
+                ColumnKind.Frame -> createFrameColumn(name, values as List<AnyFrame>).asDataColumn().cast()
+            }
+
+        public inline fun <reified T> create(name: String, values: List<T>, infer: Infer = Infer.None): DataColumn<T> =
+            create(name, values, typeOf<T>(), infer)
+
+        public fun empty(name: String = ""): AnyCol = createValueColumn(name, emptyList<Unit>(), typeOf<Unit>())
+    }
+
+    public fun hasNulls(): Boolean = type().isMarkedNullable
+
+    override fun distinct(): DataColumn<T>
+
+    override fun get(indices: Iterable<Int>): DataColumn<T>
+
+    override fun rename(newName: String): DataColumn<T>
+
+    override fun resolveSingle(context: ColumnResolutionContext): ColumnWithPath<T>? = this.addPath()
+
+    override operator fun getValue(thisRef: Any?, property: KProperty<*>): DataColumn<T> =
+        super.getValue(thisRef, property) as DataColumn<T>
+
+    public operator fun iterator(): Iterator<T> = values().iterator()
+
+    public override operator fun get(range: IntRange): DataColumn<T>
+}
+
+public val AnyCol.name: String get() = name()
+public val AnyCol.path: ColumnPath get() = path()
+
+public val <T> DataColumn<T>.values: Iterable<T> get() = values()
+public val AnyCol.hasNulls: Boolean get() = hasNulls()
+public val AnyCol.size: Int get() = size()
+public val AnyCol.indices: IntRange get() = indices()
+
+public val AnyCol.type: KType get() = type()
+public val AnyCol.kind: ColumnKind get() = kind()
+public val AnyCol.typeClass: KClass<*>
+    get() = type.classifier as? KClass<*>
+        ?: error("Cannot cast ${type.classifier?.javaClass} to a ${KClass::class}. Column $name: $type")
+
+public fun AnyBaseCol.indices(): IntRange = 0 until size()
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/DataFrame.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/DataFrame.kt
new file mode 100644
index 000000000..c997fbffb
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/DataFrame.kt
@@ -0,0 +1,135 @@
+package org.jetbrains.kotlinx.dataframe
+
+import org.jetbrains.kotlinx.dataframe.aggregation.Aggregatable
+import org.jetbrains.kotlinx.dataframe.aggregation.AggregateGroupedBody
+import org.jetbrains.kotlinx.dataframe.annotations.HasSchema
+import org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl
+import org.jetbrains.kotlinx.dataframe.api.add
+import org.jetbrains.kotlinx.dataframe.api.cast
+import org.jetbrains.kotlinx.dataframe.api.getRows
+import org.jetbrains.kotlinx.dataframe.api.indices
+import org.jetbrains.kotlinx.dataframe.api.rows
+import org.jetbrains.kotlinx.dataframe.api.select
+import org.jetbrains.kotlinx.dataframe.api.toDataFrame
+import org.jetbrains.kotlinx.dataframe.columns.UnresolvedColumnsPolicy
+import org.jetbrains.kotlinx.dataframe.columns.toColumnSet
+import org.jetbrains.kotlinx.dataframe.impl.DataFrameImpl
+import org.jetbrains.kotlinx.dataframe.impl.DataFrameSize
+import org.jetbrains.kotlinx.dataframe.impl.getColumnsImpl
+import org.jetbrains.kotlinx.dataframe.impl.headPlusArray
+import org.jetbrains.kotlinx.dataframe.impl.headPlusIterable
+import org.jetbrains.kotlinx.dataframe.impl.schema.createEmptyDataFrame
+import org.jetbrains.kotlinx.dataframe.impl.schema.createEmptyDataFrameOf
+import org.jetbrains.kotlinx.dataframe.schema.DataFrameSchema
+import kotlin.reflect.KType
+
+/**
+ * Readonly interface for an ordered list of [columns][DataColumn].
+ *
+ * Columns in `DataFrame` have distinct non-empty [names][DataColumn.name] and equal [sizes][DataColumn.size].
+ *
+ * @param T Schema marker. It identifies column schema and is used to generate schema-specific extension properties for typed data access. It is covariant, so `DataFrame<A>` is assignable to variable of type `DataFrame<B>` if `A` is a subtype of `B`.
+ */
+@HasSchema(schemaArg = 0)
+public interface DataFrame<out T> :
+    Aggregatable<T>,
+    ColumnsContainer<T> {
+
+    public companion object {
+        public val Empty: AnyFrame = DataFrameImpl<Unit>(emptyList(), 0)
+
+        public fun empty(nrow: Int = 0): AnyFrame = if (nrow == 0) Empty else DataFrameImpl<Unit>(emptyList(), nrow)
+
+        /**
+         * Creates a DataFrame with empty columns (rows = 0).
+         * Can be used as a "null object" in aggregation operations, operations that work on columns (select, reorder, ...)
+         *
+         */
+        public inline fun <reified T> emptyOf(): DataFrame<T> = createEmptyDataFrameOf(T::class).cast()
+
+        /**
+         * Creates a DataFrame with empty columns (rows = 0).
+         * Can be used as a "null object" in aggregation operations, operations that work on columns (select, reorder, ...)
+         */
+        public fun empty(schema: DataFrameSchema): AnyFrame = schema.createEmptyDataFrame()
+    }
+
+    // region columns
+
+    public fun columnNames(): List<String>
+
+    public fun columnTypes(): List<KType>
+
+    // endregion
+
+    // region rows
+
+    public fun rowsCount(): Int
+
+    public operator fun iterator(): Iterator<DataRow<T>> = rows().iterator()
+
+    // endregion
+
+    public fun <R> aggregate(body: AggregateGroupedBody<T, R>): DataRow<T>
+
+    // region get columns
+
+    /**
+     * Returns a list of columns selected by [columns], a [ColumnsSelectionDsl].
+     *
+     * NOTE: This doesn't work in [ColumnsSelectionDsl], use [ColumnsSelectionDsl.cols] to select columns by predicate.
+     */
+    override fun <C> get(columns: ColumnsSelector<T, C>): List<DataColumn<C>> =
+        getColumnsImpl(UnresolvedColumnsPolicy.Fail, columns)
+
+    // endregion
+
+    // region get rows
+
+    public operator fun get(index: Int): DataRow<T>
+
+    public operator fun get(indices: Iterable<Int>): DataFrame<T> = getRows(indices)
+
+    public operator fun get(range: IntRange): DataFrame<T> = getRows(range)
+
+    public operator fun get(first: IntRange, vararg ranges: IntRange): DataFrame<T> =
+        getRows(headPlusArray(first, ranges).asSequence().flatMap { it.asSequence() }.asIterable())
+
+    public operator fun get(firstIndex: Int, vararg otherIndices: Int): DataFrame<T> =
+        get(headPlusIterable(firstIndex, otherIndices.asIterable()))
+
+    // endregion
+
+    // region plus columns
+
+    public operator fun plus(col: AnyBaseCol): DataFrame<T> = add(col)
+
+    public operator fun plus(cols: Iterable<AnyBaseCol>): DataFrame<T> = (columns() + cols).toDataFrame().cast()
+
+    // endregion
+}
+
+// region get columns
+
+/**
+ * Returns a list of columns selected by [columns], a [ColumnsSelectionDsl].
+ */
+public operator fun <T, C> DataFrame<T>.get(columns: ColumnsSelector<T, C>): List<DataColumn<C>> = this.get(columns)
+
+public operator fun <T> DataFrame<T>.get(first: AnyColumnReference, vararg other: AnyColumnReference): DataFrame<T> =
+    select { (listOf(first) + other).toColumnSet() }
+
+public operator fun <T> DataFrame<T>.get(first: String, vararg other: String): DataFrame<T> =
+    select { (listOf(first) + other).toColumnSet() }
+
+public operator fun <T> DataFrame<T>.get(columnRange: ClosedRange<String>): DataFrame<T> =
+    select { columnRange.start..columnRange.endInclusive }
+
+// endregion
+
+internal val ColumnsContainer<*>.ncol get() = columnsCount()
+internal val AnyFrame.nrow get() = rowsCount()
+internal val AnyFrame.indices get() = indices()
+internal val AnyFrame.size: DataFrameSize get() = size()
+
+public fun AnyFrame.size(): DataFrameSize = DataFrameSize(ncol, nrow)
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/DataRow.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/DataRow.kt
new file mode 100644
index 000000000..68399d748
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/DataRow.kt
@@ -0,0 +1,147 @@
+package org.jetbrains.kotlinx.dataframe
+
+import org.jetbrains.kotlinx.dataframe.api.next
+import org.jetbrains.kotlinx.dataframe.api.prev
+import org.jetbrains.kotlinx.dataframe.columns.ColumnKind
+import org.jetbrains.kotlinx.dataframe.columns.ColumnPath
+import org.jetbrains.kotlinx.dataframe.columns.ColumnReference
+import org.jetbrains.kotlinx.dataframe.impl.columnName
+import org.jetbrains.kotlinx.dataframe.impl.owner
+import org.jetbrains.kotlinx.dataframe.impl.toIterable
+import kotlin.reflect.KProperty
+
+/**
+ * Single row of a [DataFrame].
+ *
+ * @param T Schema marker. See [DataFrame] for details
+ */
+public interface DataRow<out T> {
+
+    public fun index(): Int
+
+    public fun df(): DataFrame<T>
+
+    // region get cell value
+
+    public operator fun get(columnIndex: Int): Any?
+
+    public operator fun <R> get(expression: RowExpression<T, R>): R = expression(this, this)
+
+    public operator fun <R> get(column: ColumnReference<R>): R
+
+    public operator fun <R> get(columns: List<ColumnReference<R>>): List<R> = columns.map { get(it) }
+
+    public operator fun <R> get(property: KProperty<R>): R = get(property.columnName) as R
+
+    public operator fun get(first: AnyColumnReference, vararg other: AnyColumnReference): DataRow<T> =
+        owner.get(first, *other)[index]
+
+    public operator fun get(first: String, vararg other: String): DataRow<T> = owner.get(first, *other)[index]
+
+    public operator fun get(path: ColumnPath): Any? = owner.get(path)[index]
+
+    public operator fun get(name: String): Any?
+
+    public fun getColumnGroup(columnName: String): AnyRow {
+        val value = get(columnName)
+        if (value == null) {
+            val kind = df()[columnName].kind()
+            if (kind != ColumnKind.Group) {
+                error("Cannot cast null value of a $kind to a ${DataRow::class}")
+            }
+        }
+        return value as AnyRow
+    }
+
+    public fun getFrameColumn(columnName: String): AnyFrame {
+        val value = get(columnName)
+        if (value == null) {
+            val kind = df()[columnName].kind()
+            if (kind != ColumnKind.Frame) {
+                error("Cannot cast null value of a $kind to a ${DataFrame::class}")
+            }
+        }
+        return value as AnyFrame
+    }
+
+    public fun getOrNull(name: String): Any?
+
+    public fun <R> getValueOrNull(column: ColumnReference<R>): R?
+
+    // endregion
+
+    public fun values(): List<Any?>
+
+    public operator fun String.get(vararg path: String): ColumnPath = ColumnPath(listOf(this) + path)
+
+    public operator fun <R> ColumnReference<R>.invoke(): R = get(this)
+
+    public operator fun <R> String.invoke(): R = this@DataRow[this@invoke] as R
+
+    public operator fun <R> ColumnPath.invoke(): R = this@DataRow.get(this) as R
+
+    public fun forwardIterable(): Iterable<DataRow<T>> = this.toIterable { it.next }
+
+    public fun backwardIterable(): Iterable<DataRow<T>> = this.toIterable { it.prev }
+
+    public operator fun <R : Comparable<R>> ColumnReference<R>.compareTo(other: R): Int = get(this).compareTo(other)
+
+    public operator fun ColumnReference<Int>.plus(a: Int): Int = get(this) + a
+
+    public operator fun ColumnReference<Long>.plus(a: Long): Long = get(this) + a
+
+    public operator fun ColumnReference<Double>.plus(a: Double): Double = get(this) + a
+
+    public operator fun ColumnReference<String>.plus(a: String): String = get(this) + a
+
+    public operator fun Int.plus(col: ColumnReference<Int>): Int = this + get(col)
+
+    public operator fun Long.plus(col: ColumnReference<Long>): Long = this + get(col)
+
+    public operator fun Double.plus(col: ColumnReference<Double>): Double = this + get(col)
+
+    public operator fun ColumnReference<Int>.minus(a: Int): Int = get(this) - a
+
+    public operator fun ColumnReference<Long>.minus(a: Long): Long = get(this) - a
+
+    public operator fun ColumnReference<Double>.minus(a: Double): Double = get(this) - a
+
+    public operator fun Int.minus(col: ColumnReference<Int>): Int = this - get(col)
+
+    public operator fun Long.minus(col: ColumnReference<Long>): Long = this - get(col)
+
+    public operator fun Double.minus(col: ColumnReference<Double>): Double = this - get(col)
+
+    public operator fun ColumnReference<Int>.times(a: Int): Int = get(this) * a
+
+    public operator fun ColumnReference<Long>.times(a: Long): Long = get(this) * a
+
+    public operator fun ColumnReference<Double>.times(a: Double): Double = get(this) * a
+
+    public operator fun ColumnReference<Double>.times(a: Int): Double = get(this) * a
+
+    public operator fun ColumnReference<Long>.times(a: Int): Long = get(this) * a
+
+    public operator fun ColumnReference<Double>.times(a: Long): Double = get(this) * a
+
+    public operator fun ColumnReference<Int>.div(a: Int): Int = get(this) / a
+
+    public operator fun ColumnReference<Long>.div(a: Long): Long = get(this) / a
+
+    public operator fun ColumnReference<Double>.div(a: Double): Double = get(this) / a
+
+    public operator fun ColumnReference<Double>.div(a: Int): Double = get(this) / a
+
+    public operator fun ColumnReference<Long>.div(a: Int): Long = get(this) / a
+
+    public operator fun ColumnReference<Double>.div(a: Long): Double = get(this) / a
+
+    public companion object {
+        public val empty: AnyRow = DataFrame.empty(1)[0]
+    }
+}
+
+internal val AnyRow.values: List<Any?> get() = values()
+internal val AnyRow.index: Int get() = index()
+internal val <T> DataRow<T>.prev: DataRow<T>? get() = this.prev()
+internal val <T> DataRow<T>.next: DataRow<T>? get() = this.next()
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/aggregation/Aggregatable.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/aggregation/Aggregatable.kt
new file mode 100644
index 000000000..7cb74c05f
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/aggregation/Aggregatable.kt
@@ -0,0 +1,3 @@
+package org.jetbrains.kotlinx.dataframe.aggregation
+
+public interface Aggregatable<out T>
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/aggregation/AggregateDsl.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/aggregation/AggregateDsl.kt
new file mode 100644
index 000000000..6bd7c2052
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/aggregation/AggregateDsl.kt
@@ -0,0 +1,35 @@
+package org.jetbrains.kotlinx.dataframe.aggregation
+
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.annotations.HasSchema
+import org.jetbrains.kotlinx.dataframe.annotations.Interpretable
+import org.jetbrains.kotlinx.dataframe.api.ColumnSelectionDsl
+import org.jetbrains.kotlinx.dataframe.api.pathOf
+import org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor
+import org.jetbrains.kotlinx.dataframe.impl.aggregation.ValueWithDefault
+import org.jetbrains.kotlinx.dataframe.impl.aggregation.receivers.internal
+import org.jetbrains.kotlinx.dataframe.impl.columnName
+import kotlin.reflect.KProperty
+import kotlin.reflect.typeOf
+
+@HasSchema(schemaArg = 0)
+public abstract class AggregateDsl<out T> :
+    DataFrame<T>,
+    ColumnSelectionDsl<T> {
+
+    @Interpretable("GroupByInto")
+    public inline infix fun <reified R> R.into(name: String): NamedValue =
+        internal().yield(pathOf(name), this, typeOf<R>())
+
+    public inline infix fun <reified R> R.into(column: ColumnAccessor<R>): NamedValue =
+        internal().yield(pathOf(column.name()), this, typeOf<R>())
+
+    public inline infix fun <reified R> R.into(column: KProperty<R>): NamedValue =
+        internal().yield(pathOf(column.columnName), this, typeOf<R>())
+
+    public infix fun <R> R.default(defaultValue: R): Any =
+        when (this) {
+            is NamedValue -> this.also { it.default = defaultValue }
+            else -> ValueWithDefault(this, defaultValue)
+        }
+}
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/aggregation/AggregateGroupedDsl.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/aggregation/AggregateGroupedDsl.kt
new file mode 100644
index 000000000..43b529522
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/aggregation/AggregateGroupedDsl.kt
@@ -0,0 +1,3 @@
+package org.jetbrains.kotlinx.dataframe.aggregation
+
+public abstract class AggregateGroupedDsl<out T> : AggregateDsl<T>()
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/aggregation/ColumnsForAggregateSelectionDsl.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/aggregation/ColumnsForAggregateSelectionDsl.kt
new file mode 100644
index 000000000..f3d91b35f
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/aggregation/ColumnsForAggregateSelectionDsl.kt
@@ -0,0 +1,31 @@
+package org.jetbrains.kotlinx.dataframe.aggregation
+
+import org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl
+import org.jetbrains.kotlinx.dataframe.api.pathOf
+import org.jetbrains.kotlinx.dataframe.columns.ColumnPath
+import org.jetbrains.kotlinx.dataframe.columns.ColumnSet
+import org.jetbrains.kotlinx.dataframe.columns.SingleColumn
+import org.jetbrains.kotlinx.dataframe.impl.aggregation.ConfiguredAggregateColumn
+
+public interface ColumnsForAggregateSelectionDsl<out T> : ColumnsSelectionDsl<T> {
+
+    public infix fun <C> ColumnSet<C>.default(defaultValue: C): ColumnSet<C> =
+        ConfiguredAggregateColumn.withDefault(this, defaultValue)
+
+    public infix fun <C> SingleColumn<C>.default(defaultValue: C): SingleColumn<C> =
+        ConfiguredAggregateColumn.withDefault(this, defaultValue)
+
+    public fun path(vararg names: String): ColumnPath = ColumnPath(names.asList())
+
+    public infix fun <C> ColumnSet<C>.into(name: String): ColumnSet<C> =
+        ConfiguredAggregateColumn.withPath(this, pathOf(name))
+
+    public infix fun <C> SingleColumn<C>.into(name: String): SingleColumn<C> =
+        ConfiguredAggregateColumn.withPath(this, pathOf(name))
+
+    public infix fun <C> ColumnSet<C>.into(path: ColumnPath): ColumnSet<C> =
+        ConfiguredAggregateColumn.withPath(this, path)
+
+    public infix fun <C> SingleColumn<C>.into(path: ColumnPath): SingleColumn<C> =
+        ConfiguredAggregateColumn.withPath(this, path)
+}
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/aggregation/NamedValue.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/aggregation/NamedValue.kt
new file mode 100644
index 000000000..0a709ed44
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/aggregation/NamedValue.kt
@@ -0,0 +1,34 @@
+package org.jetbrains.kotlinx.dataframe.aggregation
+
+import org.jetbrains.kotlinx.dataframe.columns.ColumnPath
+import org.jetbrains.kotlinx.dataframe.impl.aggregation.ValueWithDefault
+import org.jetbrains.kotlinx.dataframe.impl.emptyPath
+import kotlin.reflect.KType
+
+@Suppress("DataClassPrivateConstructor")
+public data class NamedValue private constructor(
+    val path: ColumnPath,
+    val value: Any?,
+    val type: KType?,
+    var default: Any?,
+    val guessType: Boolean = false,
+) {
+    public companion object {
+        internal fun create(
+            path: ColumnPath,
+            value: Any?,
+            type: KType?,
+            defaultValue: Any?,
+            guessType: Boolean = false,
+        ): NamedValue =
+            when (value) {
+                is ValueWithDefault<*> -> create(path, value.value, type, value.default, guessType)
+                else -> NamedValue(path, value, type, defaultValue, guessType)
+            }
+
+        internal fun aggregator(builder: AggregateGroupedDsl<*>): NamedValue =
+            NamedValue(emptyPath(), builder, null, null, false)
+    }
+
+    val name: String get() = path.last()
+}
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/aggregation/aliases.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/aggregation/aliases.kt
new file mode 100644
index 000000000..cbc5e4146
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/aggregation/aliases.kt
@@ -0,0 +1,10 @@
+package org.jetbrains.kotlinx.dataframe.aggregation
+
+import org.jetbrains.kotlinx.dataframe.Selector
+import org.jetbrains.kotlinx.dataframe.columns.ColumnsResolver
+
+public typealias AggregateBody<T, R> = Selector<AggregateDsl<T>, R>
+
+public typealias AggregateGroupedBody<G, R> = Selector<AggregateGroupedDsl<G>, R>
+
+public typealias ColumnsForAggregateSelector<T, C> = Selector<ColumnsForAggregateSelectionDsl<T>, ColumnsResolver<C>>
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/aliases.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/aliases.kt
new file mode 100644
index 000000000..4f1335a9b
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/aliases.kt
@@ -0,0 +1,211 @@
+package org.jetbrains.kotlinx.dataframe
+
+import org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl
+import org.jetbrains.kotlinx.dataframe.columns.BaseColumn
+import org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor
+import org.jetbrains.kotlinx.dataframe.columns.ColumnReference
+import org.jetbrains.kotlinx.dataframe.columns.ColumnSet
+import org.jetbrains.kotlinx.dataframe.columns.ColumnWithPath
+import org.jetbrains.kotlinx.dataframe.columns.ColumnsResolver
+import org.jetbrains.kotlinx.dataframe.columns.SingleColumn
+
+/**
+ * ## Predicate
+ *
+ * [Predicate] is a lambda function expecting a [Boolean] result given an instance of `T` as `it`.
+ *
+ * Shorthand for:
+ * ```kotlin
+ * (it: T) -> Boolean
+ * ```
+ */
+public typealias Predicate<T> = (it: T) -> Boolean
+
+/**
+ * ## Selector
+ *
+ * [Selector] is a lambda function expecting an `R` result given an instance of `T` as context (`this` and `it`).
+ *
+ * Shorthand for:
+ * ```kotlin
+ * T.(it: T) -> R
+ * ```
+ */
+public typealias Selector<T, R> = T.(it: T) -> R
+
+// region selectors
+
+/**
+ * ## DataFrame Expression
+ *
+ * [DataFrameExpression] is a lambda function expecting an `R` result given an instance of [DataFrame]`<T>` as context
+ * (`this` and `it`).
+ * `R` can be selected or expressed.
+ *
+ * Shorthand for:
+ * ```kotlin
+ * DataFrame<T>.(it: DataFrame<T>) -> R
+ * ```
+ */
+public typealias DataFrameExpression<T, R> = Selector<DataFrame<T>, R>
+
+/**
+ * ## Row Expression
+ *
+ * [RowExpression] is a lambda function expecting an `R` result given an instance of [DataRow]`<T>` as context
+ * (`this` and `it`). `R` can be selected or expressed.
+ *
+ * Shorthand for:
+ * ```kotlin
+ * DataRow<T>.(it: DataRow<T>) -> R
+ * ```
+ */
+public typealias RowExpression<T, R> = Selector<DataRow<T>, R>
+
+/**
+ * ## Row Value Expression
+ *
+ * [RowValueExpression] is a lambda function expecting an `R` result given the value `it: C` and an
+ * instance of [DataRow]`<T>` as context (`this`). `R` can be selected or expressed.
+ *
+ * Shorthand for:
+ * ```kotlin
+ * DataRow<T>.(it: C) -> R
+ * ```
+ */
+public typealias RowValueExpression<T, C, R> = DataRow<T>.(it: C) -> R
+
+/**
+ * ## Row Column Expression
+ *
+ * [RowColumnExpression] is a lambda function expecting an `R` result given an instance of [DataRow]`<T>` as
+ * `row` and [DataColumn]`<C>` as `col`. `R` can be selected or expressed.
+ *
+ * Shorthand for:
+ * ```kotlin
+ * (row: DataRow<T>, col: DataColumn<C>) -> R
+ * ```
+ */
+public typealias RowColumnExpression<T, C, R> = (row: DataRow<T>, col: DataColumn<C>) -> R
+
+/**
+ * ## Column Expression
+ *
+ * [ColumnExpression] is a lambda function expecting an `R` result given an instance of [DataColumn]`<C>` as context
+ * (`this` and `it`). `R` can be selected or expressed.
+ *
+ * Shorthand for:
+ * ```kotlin
+ * DataColumn<C>.(it: DataColumn<C>) -> R
+ * ```
+ */
+public typealias ColumnExpression<C, R> = Selector<DataColumn<C>, R>
+
+/**
+ * ## Column Selector
+ *
+ * [ColumnSelector] is a lambda function expecting a [SingleColumn]<`C`> result given an instance of [ColumnsSelectionDsl]`<T>`
+ * as context (`this` and `it`). [SingleColumn]`<C>` can be selected or expressed.
+ *
+ * See [Columns Selection DSL][ColumnsSelectionDsl] for more information.
+ *
+ * Shorthand for:
+ * ```kotlin
+ * ColumnsSelectionDsl<T>.(it: ColumnsSelectionDsl<T>) -> SingleColumn<C>
+ * ```
+ */
+public typealias ColumnSelector<T, C> = Selector<ColumnsSelectionDsl<T>, SingleColumn<C>>
+
+/**
+ * ## Columns Selector
+ *
+ * [ColumnsSelector] is a lambda function expecting a [ColumnsResolver]<`C`> ([SingleColumn]<`C`> or [ColumnSet]<`C`>)
+ * result given an instance of [ColumnsSelectionDsl]`<T>` as context (`this` and `it`).
+ * [ColumnsResolver]<`C`> can be selected or expressed.
+ *
+ * See [Columns Selection DSL][ColumnsSelectionDsl] for more information.
+ *
+ * Shorthand for:
+ * ```kotlin
+ * ColumnsSelectionDsl<T>.(it: ColumnsSelectionDsl<T>) -> ColumnsResolver<C>
+ * ```
+ */
+public typealias ColumnsSelector<T, C> = Selector<ColumnsSelectionDsl<T>, ColumnsResolver<C>>
+
+// endregion
+
+// region filters
+
+/**
+ * ## Row Filter
+ *
+ * [RowFilter] is a lambda function expecting a [Boolean] result given an instance of [DataRow]`<T>` as context
+ * (`this` and `it`).
+ *
+ * Return `true` if the row should be included in the result.
+ *
+ * Shorthand for:
+ * ```kotlin
+ * DataRow<T>.(it: DataRow<T>) -> Boolean
+ * ```
+ */
+public typealias RowFilter<T> = RowExpression<T, Boolean>
+
+/**
+ * ## Column Filter
+ *
+ * [ColumnFilter] is a lambda function expecting a [Boolean] result given an instance of [DataColumn]`<C>` as context
+ * (`this` and `it`).
+ *
+ * Return `true` if the column should be included in the result.
+ *
+ * Shorthand for:
+ * ```kotlin
+ * (it: ColumnWithPath<T>) -> Boolean
+ * ```
+ */
+public typealias ColumnFilter<T> = Predicate<ColumnWithPath<T>>
+
+/**
+ * ## Row Value Filter
+ *
+ * [RowValueFilter] is a lambda function expecting a [Boolean] result given the value `it: C` and an instance
+ * of [DataRow]`<T>` as context (`this`).
+ *
+ * Return `true` if the row should be included in the result.
+ *
+ * Shorthand for:
+ * ```kotlin
+ * DataRow<T>.(it: C) -> Boolean
+ * ```
+ */
+public typealias RowValueFilter<T, C> = RowValueExpression<T, C, Boolean>
+
+// endregion
+
+// region columns
+
+public typealias AnyColumnReference = ColumnReference<*>
+
+public typealias ColumnGroupReference = ColumnReference<AnyRow>
+public typealias ColumnGroupAccessor<T> = ColumnAccessor<DataRow<T>>
+public typealias AnyColumnGroupAccessor = ColumnGroupAccessor<*>
+
+public typealias DoubleCol = DataColumn<Double?>
+public typealias BooleanCol = DataColumn<Boolean?>
+public typealias IntCol = DataColumn<Int?>
+public typealias NumberCol = DataColumn<Number?>
+public typealias StringCol = DataColumn<String?>
+public typealias AnyCol = DataColumn<*>
+
+// endregion
+
+// region Any*
+
+public typealias AnyFrame = DataFrame<*>
+
+public typealias AnyRow = DataRow<*>
+
+public typealias AnyBaseCol = BaseColumn<*>
+
+// endregion
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/annotations/ColumnName.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/annotations/ColumnName.kt
new file mode 100644
index 000000000..11ea05df3
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/annotations/ColumnName.kt
@@ -0,0 +1,4 @@
+package org.jetbrains.kotlinx.dataframe.annotations
+
+@Target(AnnotationTarget.PROPERTY)
+public annotation class ColumnName(val name: String)
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/annotations/DataSchema.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/annotations/DataSchema.kt
new file mode 100644
index 000000000..2422c1d33
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/annotations/DataSchema.kt
@@ -0,0 +1,4 @@
+package org.jetbrains.kotlinx.dataframe.annotations
+
+@Target(AnnotationTarget.CLASS)
+public annotation class DataSchema(val isOpen: Boolean = true)
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/annotations/ImportDataSchema.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/annotations/ImportDataSchema.kt
new file mode 100644
index 000000000..00f99ac5d
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/annotations/ImportDataSchema.kt
@@ -0,0 +1,82 @@
+package org.jetbrains.kotlinx.dataframe.annotations
+
+import org.jetbrains.kotlinx.dataframe.api.JsonPath
+import org.jetbrains.kotlinx.dataframe.api.KeyValueProperty
+import org.jetbrains.kotlinx.dataframe.columns.ColumnGroup
+import org.jetbrains.kotlinx.dataframe.columns.FrameColumn
+import org.jetbrains.kotlinx.dataframe.io.JSON
+
+/**
+ * Annotation preprocessing will generate a DataSchema interface from the data at `path`.
+ * Data must be of supported format: CSV, JSON, Apache Arrow, Excel, OpenAPI (Swagger) in YAML/JSON, JDBC.
+ * Generated data schema has properties inferred from data and a companion object with `read method`.
+ * `read method` is either `readCSV` or `readJson` that returns `DataFrame<name>`
+ *
+ * @param name name of the generated interface
+ * @param path URL or relative path to data.
+ * If a path starts with protocol (http, https, ftp, jdbc), it's considered a URL.
+ * Otherwise, it's treated as a relative path.
+ * By default, it will be resolved relatively to project dir, i.e. File(projectDir, path)
+ * You can configure it by passing `dataframe.resolutionDir` option to preprocessor,
+ * see https://kotlinlang.org/docs/ksp-quickstart.html#pass-options-to-processors
+ * @param visibility visibility of the generated interface.
+ * @param normalizationDelimiters if not empty, split property names by delimiters,
+ * lowercase parts and join to camel case. Set empty list to disable normalization
+ * @param withDefaultPath if `true`, generate `defaultPath` property to the data schema's companion object and make it default argument for a `read method`
+ * @param csvOptions options to parse CSV data. Not used when data is not Csv
+ * @param jsonOptions options to parse JSON data. Not used when data is not Json
+ * @param jdbcOptions options to parse data from a database via JDBC. Not used when data is not stored in the database
+ */
+@Retention(AnnotationRetention.SOURCE)
+@Target(AnnotationTarget.FILE)
+@Repeatable
+public annotation class ImportDataSchema(
+    val name: String,
+    val path: String,
+    val visibility: DataSchemaVisibility = DataSchemaVisibility.IMPLICIT_PUBLIC,
+    val normalizationDelimiters: CharArray = ['\t', ' ', '_'],
+    val withDefaultPath: Boolean = true,
+    val csvOptions: CsvOptions = CsvOptions(','),
+    val jsonOptions: JsonOptions = JsonOptions(),
+    val jdbcOptions: JdbcOptions = JdbcOptions(),
+)
+
+public enum class DataSchemaVisibility {
+    INTERNAL,
+    IMPLICIT_PUBLIC,
+    EXPLICIT_PUBLIC,
+}
+
+public annotation class CsvOptions(public val delimiter: Char)
+
+/**
+ * An annotation class that represents options for JDBC connection.
+ *
+ * @property [user] The username for the JDBC connection. Default value is an empty string.
+ * If [extractCredFromEnv] is true, the [user] value will be interpreted as key for system environment variable.
+ * @property [password] The password for the JDBC connection. Default value is an empty string.
+ * If [extractCredFromEnv] is true, the [password] value will be interpreted as key for system environment variable.
+ * @property [extractCredFromEnv] Whether to extract the JDBC credentials from environment variables. Default value is false.
+ * @property [tableName] The name of the table for the JDBC connection. Default value is an empty string.
+ * @property [sqlQuery] The SQL query to be executed in the JDBC connection. Default value is an empty string.
+ */
+public annotation class JdbcOptions(
+    public val user: String = "",
+    public val password: String = "",
+    public val extractCredFromEnv: Boolean = false,
+    public val tableName: String = "",
+    public val sqlQuery: String = "",
+)
+
+public annotation class JsonOptions(
+    /** Allows the choice of how to handle type clashes when reading a JSON file. */
+    public val typeClashTactic: JSON.TypeClashTactic = JSON.TypeClashTactic.ARRAY_AND_VALUE_COLUMNS,
+    /**
+     * List of [JsonPath]s where instead of a [ColumnGroup], a [FrameColumn]<[KeyValueProperty]>
+     *     will be created.
+     *
+     * Example:
+     * `["""$["store"]["book"][*]["author"]"""]`
+     */
+    public val keyValuePaths: Array<String> = [],
+)
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/annotations/Plugin.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/annotations/Plugin.kt
new file mode 100644
index 000000000..0493f6254
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/annotations/Plugin.kt
@@ -0,0 +1,45 @@
+package org.jetbrains.kotlinx.dataframe.annotations
+
+@Target(AnnotationTarget.CLASS)
+public annotation class HasSchema(val schemaArg: Int)
+
+/**
+ * Compiler plugin will evaluate compile time value of the annotated function.
+ * Needed because some function calls only serve as a part of overall compile time DataSchema evaluation
+ * There's no need to update return type of such calls
+ */
+public annotation class Interpretable(val interpreter: String)
+
+/**
+ * Compiler plugin will replace return type of calls to the annotated function
+ */
+public annotation class Refine
+
+internal annotation class OptInRefine
+
+@Retention(AnnotationRetention.SOURCE)
+@Target(AnnotationTarget.FILE, AnnotationTarget.EXPRESSION)
+public annotation class DisableInterpretation
+
+@Retention(AnnotationRetention.SOURCE)
+@Target(AnnotationTarget.EXPRESSION)
+public annotation class Import
+
+@Target(AnnotationTarget.PROPERTY)
+public annotation class Order(val order: Int)
+
+/**
+ * For internal use
+ * Compiler plugin materializes schemas as classes.
+ * These classes have two kinds of properties:
+ * 1. Scope properties that only serve as a reference for internal property resolution
+ * 2. Schema properties that reflect dataframe structure
+ * Scope properties need
+ * to be excluded in IDE plugin and in [org.jetbrains.kotlinx.dataframe.codeGen.MarkersExtractor.get]
+ * This annotation serves to distinguish between the two where needed
+ */
+@Target(AnnotationTarget.PROPERTY)
+public annotation class ScopeProperty
+
+@Target(AnnotationTarget.FUNCTION)
+internal annotation class Check
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/ColumnAccessorApi.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/ColumnAccessorApi.kt
new file mode 100644
index 000000000..834fbdd5f
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/ColumnAccessorApi.kt
@@ -0,0 +1,5 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor
+
+public inline fun <reified T> ColumnAccessor<T>.nullable(): ColumnAccessor<T?> = cast()
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/ColumnReferenceApi.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/ColumnReferenceApi.kt
new file mode 100644
index 000000000..40c90f36d
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/ColumnReferenceApi.kt
@@ -0,0 +1,29 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import org.jetbrains.kotlinx.dataframe.DataColumn
+import org.jetbrains.kotlinx.dataframe.columns.ColumnReference
+import org.jetbrains.kotlinx.dataframe.columns.ValueColumn
+import org.jetbrains.kotlinx.dataframe.impl.asList
+import kotlin.reflect.typeOf
+
+internal val ColumnReference<*>.name: String get() = name()
+
+public inline fun <reified T> ColumnReference<T>.withValues(vararg values: T): ValueColumn<T> =
+    withValues(values.asIterable())
+
+public inline fun <reified T> ColumnReference<T>.withValues(values: Iterable<T>): ValueColumn<T> =
+    DataColumn.createValueColumn(name(), values.asList(), typeOf<T>())
+
+public infix fun <C : Comparable<C>> ColumnReference<C>.gt(value: C): ColumnReference<Boolean> = map { it > value }
+
+public infix fun <C : Comparable<C>> ColumnReference<C>.lt(value: C): ColumnReference<Boolean> = map { it < value }
+
+public infix fun <C> ColumnReference<C>.eq(value: C): ColumnReference<Boolean> = map { it == value }
+
+public infix fun <C> ColumnReference<C>.neq(value: C): ColumnReference<Boolean> = map { it != value }
+
+public fun ColumnReference<String?>.length(): ColumnReference<Int> = map { it?.length ?: 0 }
+
+public fun ColumnReference<String?>.lowercase(): ColumnReference<String?> = map { it?.lowercase() }
+
+public fun ColumnReference<String?>.uppercase(): ColumnReference<String?> = map { it?.uppercase() }
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/ColumnSelectionDsl.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/ColumnSelectionDsl.kt
new file mode 100644
index 000000000..24da6d8c9
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/ColumnSelectionDsl.kt
@@ -0,0 +1,274 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import org.jetbrains.kotlinx.dataframe.ColumnsContainer
+import org.jetbrains.kotlinx.dataframe.DataColumn
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.DataRow
+import org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor
+import org.jetbrains.kotlinx.dataframe.columns.ColumnGroup
+import org.jetbrains.kotlinx.dataframe.columns.ColumnPath
+import org.jetbrains.kotlinx.dataframe.columns.ColumnReference
+import org.jetbrains.kotlinx.dataframe.columns.FrameColumn
+import org.jetbrains.kotlinx.dataframe.impl.columns.getColumn
+import kotlin.reflect.KProperty
+
+/** [Column Selection DSL][ColumnSelectionDsl] */
+internal interface ColumnSelectionDslLink
+
+public interface ColumnSelectionDsl<out T> : ColumnsContainer<T> {
+
+    /**
+     * Retrieves the value of this [ColumnReference] or [-Accessor][ColumnAccessor] from
+     * the [DataFrame].
+     *
+     * This is a shorthand for [get][ColumnsContainer.get]`(myColumn)`.
+     * @throws [IllegalArgumentException] if the column is not found.
+     */
+    private interface CommonColumnReferenceInvokeDocs
+
+    /**
+     * Retrieves the value of this [ColumnReference][org.jetbrains.kotlinx.dataframe.columns.ColumnReference] or [-Accessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] from
+     * the [DataFrame][org.jetbrains.kotlinx.dataframe.DataFrame].
+     *
+     * This is a shorthand for [get][org.jetbrains.kotlinx.dataframe.ColumnsContainer.get]`(myColumn)`.
+     * @throws [IllegalArgumentException] if the column is not found.
+     * @return The [DataColumn] this [Column Reference][ColumnReference] or [-Accessor][ColumnAccessor] points to.
+     */
+    public operator fun <C> ColumnReference<C>.invoke(): DataColumn<C> = get(this)
+
+    /**
+     * Retrieves the value of this [ColumnReference][org.jetbrains.kotlinx.dataframe.columns.ColumnReference] or [-Accessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] from
+     * the [DataFrame][org.jetbrains.kotlinx.dataframe.DataFrame].
+     *
+     * This is a shorthand for [get][org.jetbrains.kotlinx.dataframe.ColumnsContainer.get]`(myColumn)`.
+     * @throws [IllegalArgumentException] if the column is not found.
+     * @return The [ColumnGroup] this [Column Reference][ColumnReference] or [-Accessor][ColumnAccessor] points to.
+     */
+    public operator fun <T> ColumnReference<DataRow<T>>.invoke(): ColumnGroup<T> = get(this)
+
+    /**
+     * Retrieves the value of this [ColumnReference][org.jetbrains.kotlinx.dataframe.columns.ColumnReference] or [-Accessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] from
+     * the [DataFrame][org.jetbrains.kotlinx.dataframe.DataFrame].
+     *
+     * This is a shorthand for [get][org.jetbrains.kotlinx.dataframe.ColumnsContainer.get]`(myColumn)`.
+     * @throws [IllegalArgumentException] if the column is not found.
+     * @return The [FrameColumn] this [Column Reference][ColumnReference] or [-Accessor][ColumnAccessor] points to.
+     */
+    public operator fun <T> ColumnReference<DataFrame<T>>.invoke(): FrameColumn<T> = get(this)
+
+    /**
+     * Retrieves the value of this [ColumnPath] from the [DataFrame].
+     * This is a shorthand for [getColumn][ColumnsContainer.getColumn]`(myColumnPath)` and
+     * is most often used in combination with `operator fun String.get(column: String)`,
+     * for instance:
+     * ```kotlin
+     * "myColumn"["myNestedColumn"]<NestedColumnType>()
+     * ```
+     *
+     * @throws [IllegalArgumentException] if the column is not found.
+     * @return The [DataColumn] this [ColumnPath] points to.
+     */
+    public operator fun <C> ColumnPath.invoke(): DataColumn<C> = getColumn(this).cast()
+
+    /**
+     * Retrieves the value of this [KProperty Accessor][KProperty] from the [DataFrame].
+     *
+     * This is a shorthand for [get][ColumnsContainer.get]`(MyType::myColumn)`.
+     * @throws [IllegalArgumentException] if the column is not found.
+     */
+    private interface CommonKPropertyInvokeDocs
+
+    /**
+     * Retrieves the value of this [KProperty Accessor][KProperty] from the [DataFrame][org.jetbrains.kotlinx.dataframe.DataFrame].
+     *
+     * This is a shorthand for [get][org.jetbrains.kotlinx.dataframe.ColumnsContainer.get]`(MyType::myColumn)`.
+     * @throws [IllegalArgumentException] if the column is not found.
+     * @return The [DataColumn] this [KProperty Accessor][KProperty] points to.
+     */
+    public operator fun <T> KProperty<T>.invoke(): DataColumn<T> = this@ColumnSelectionDsl[this]
+
+    /**
+     * Retrieves the value of this [KProperty Accessor][KProperty] from the [DataFrame][org.jetbrains.kotlinx.dataframe.DataFrame].
+     *
+     * This is a shorthand for [get][org.jetbrains.kotlinx.dataframe.ColumnsContainer.get]`(MyType::myColumn)`.
+     * @throws [IllegalArgumentException] if the column is not found.
+     * @return The [ColumnGroup] this [KProperty Accessor][KProperty] points to.
+     */
+    public operator fun <T> KProperty<DataRow<T>>.invoke(): ColumnGroup<T> = this@ColumnSelectionDsl[this]
+
+    /**
+     * Retrieves the value of this [KProperty Accessor][KProperty] from the [DataFrame][org.jetbrains.kotlinx.dataframe.DataFrame].
+     *
+     * This is a shorthand for [get][org.jetbrains.kotlinx.dataframe.ColumnsContainer.get]`(MyType::myColumn)`.
+     * @throws [IllegalArgumentException] if the column is not found.
+     * @return The [FrameColumn] this [KProperty Accessor][KProperty] points to.
+     */
+    public operator fun <T> KProperty<DataFrame<T>>.invoke(): FrameColumn<T> = this@ColumnSelectionDsl[this]
+
+    /**
+     * Retrieves the value of this [KProperty Accessor][KProperty] from the [DataFrame].
+     *
+     * This is a shorthand for
+     *
+     * [get][ColumnsContainer.get]`(MyType::myColumnGroup).`[asColumnGroup][asColumnGroup]`().`[get][ColumnsContainer.get]`(MyOtherType::myOtherColumn)`
+     *
+     * and can instead be written as
+     *
+     * `MyType::myColumnGroup`[`[`][KProperty.get]`MyOtherType::myOtherColumn`[`]`][KProperty.get].
+     *
+     * @throws [IllegalArgumentException] if the column is not found.
+     */
+    private interface CommonKPropertyGetDocs
+
+    /**
+     * Retrieves the value of this [KProperty Accessor][KProperty] from the [DataFrame][org.jetbrains.kotlinx.dataframe.DataFrame].
+     *
+     * This is a shorthand for
+     *
+     * [get][org.jetbrains.kotlinx.dataframe.ColumnsContainer.get]`(MyType::myColumnGroup).`[asColumnGroup][org.jetbrains.kotlinx.dataframe.api.asColumnGroup]`().`[get][org.jetbrains.kotlinx.dataframe.ColumnsContainer.get]`(MyOtherType::myOtherColumn)`
+     *
+     * and can instead be written as
+     *
+     * `MyType::myColumnGroup`[`[`][kotlin.reflect.KProperty.get]`MyOtherType::myOtherColumn`[`]`][kotlin.reflect.KProperty.get].
+     *
+     * @throws [IllegalArgumentException] if the column is not found.
+     * @return The [DataColumn] these [KProperty Accessors][KProperty] point to.
+     */
+    @Suppress("INAPPLICABLE_JVM_NAME")
+    @JvmName("KPropertyDataRowGet")
+    public operator fun <T, R> KProperty<DataRow<T>>.get(column: KProperty<R>): DataColumn<R> = invoke()[column]
+
+    /**
+     * Retrieves the value of this [KProperty Accessor][KProperty] from the [DataFrame][org.jetbrains.kotlinx.dataframe.DataFrame].
+     *
+     * This is a shorthand for
+     *
+     * [get][org.jetbrains.kotlinx.dataframe.ColumnsContainer.get]`(MyType::myColumnGroup).`[asColumnGroup][org.jetbrains.kotlinx.dataframe.api.asColumnGroup]`().`[get][org.jetbrains.kotlinx.dataframe.ColumnsContainer.get]`(MyOtherType::myOtherColumn)`
+     *
+     * and can instead be written as
+     *
+     * `MyType::myColumnGroup`[`[`][kotlin.reflect.KProperty.get]`MyOtherType::myOtherColumn`[`]`][kotlin.reflect.KProperty.get].
+     *
+     * @throws [IllegalArgumentException] if the column is not found.
+     * @return The [ColumnGroup] these [KProperty Accessors][KProperty] point to.
+     */
+    @Suppress("INAPPLICABLE_JVM_NAME")
+    @JvmName("KPropertyDataRowGet")
+    public operator fun <T, R> KProperty<DataRow<T>>.get(column: KProperty<DataRow<R>>): ColumnGroup<R> =
+        invoke()[column]
+
+    /**
+     * Retrieves the value of this [KProperty Accessor][KProperty] from the [DataFrame][org.jetbrains.kotlinx.dataframe.DataFrame].
+     *
+     * This is a shorthand for
+     *
+     * [get][org.jetbrains.kotlinx.dataframe.ColumnsContainer.get]`(MyType::myColumnGroup).`[asColumnGroup][org.jetbrains.kotlinx.dataframe.api.asColumnGroup]`().`[get][org.jetbrains.kotlinx.dataframe.ColumnsContainer.get]`(MyOtherType::myOtherColumn)`
+     *
+     * and can instead be written as
+     *
+     * `MyType::myColumnGroup`[`[`][kotlin.reflect.KProperty.get]`MyOtherType::myOtherColumn`[`]`][kotlin.reflect.KProperty.get].
+     *
+     * @throws [IllegalArgumentException] if the column is not found.
+     * @return The [FrameColumn] these [KProperty Accessors][KProperty] point to.
+     */
+    @Suppress("INAPPLICABLE_JVM_NAME")
+    @JvmName("KPropertyDataRowGet")
+    public operator fun <T, R> KProperty<DataRow<T>>.get(column: KProperty<DataFrame<R>>): FrameColumn<R> =
+        invoke()[column]
+
+    /**
+     * Retrieves the value of this [KProperty Accessor][KProperty] from the [DataFrame][org.jetbrains.kotlinx.dataframe.DataFrame].
+     *
+     * This is a shorthand for
+     *
+     * [get][org.jetbrains.kotlinx.dataframe.ColumnsContainer.get]`(MyType::myColumnGroup).`[asColumnGroup][org.jetbrains.kotlinx.dataframe.api.asColumnGroup]`().`[get][org.jetbrains.kotlinx.dataframe.ColumnsContainer.get]`(MyOtherType::myOtherColumn)`
+     *
+     * and can instead be written as
+     *
+     * `MyType::myColumnGroup`[`[`][kotlin.reflect.KProperty.get]`MyOtherType::myOtherColumn`[`]`][kotlin.reflect.KProperty.get].
+     *
+     * @throws [IllegalArgumentException] if the column is not found.
+     * @return The [DataColumn] these [KProperty Accessors][KProperty] point to.
+     */
+    public operator fun <T, R> KProperty<T>.get(column: KProperty<R>): DataColumn<R> = invoke().asColumnGroup()[column]
+
+    /**
+     * Retrieves the value of this [KProperty Accessor][KProperty] from the [DataFrame][org.jetbrains.kotlinx.dataframe.DataFrame].
+     *
+     * This is a shorthand for
+     *
+     * [get][org.jetbrains.kotlinx.dataframe.ColumnsContainer.get]`(MyType::myColumnGroup).`[asColumnGroup][org.jetbrains.kotlinx.dataframe.api.asColumnGroup]`().`[get][org.jetbrains.kotlinx.dataframe.ColumnsContainer.get]`(MyOtherType::myOtherColumn)`
+     *
+     * and can instead be written as
+     *
+     * `MyType::myColumnGroup`[`[`][kotlin.reflect.KProperty.get]`MyOtherType::myOtherColumn`[`]`][kotlin.reflect.KProperty.get].
+     *
+     * @throws [IllegalArgumentException] if the column is not found.
+     * @return The [ColumnGroup] these [KProperty Accessors][KProperty] point to.
+     */
+    public operator fun <T, R> KProperty<T>.get(column: KProperty<DataRow<R>>): ColumnGroup<R> =
+        invoke().asColumnGroup()[column]
+
+    /**
+     * Retrieves the value of this [KProperty Accessor][KProperty] from the [DataFrame][org.jetbrains.kotlinx.dataframe.DataFrame].
+     *
+     * This is a shorthand for
+     *
+     * [get][org.jetbrains.kotlinx.dataframe.ColumnsContainer.get]`(MyType::myColumnGroup).`[asColumnGroup][org.jetbrains.kotlinx.dataframe.api.asColumnGroup]`().`[get][org.jetbrains.kotlinx.dataframe.ColumnsContainer.get]`(MyOtherType::myOtherColumn)`
+     *
+     * and can instead be written as
+     *
+     * `MyType::myColumnGroup`[`[`][kotlin.reflect.KProperty.get]`MyOtherType::myOtherColumn`[`]`][kotlin.reflect.KProperty.get].
+     *
+     * @throws [IllegalArgumentException] if the column is not found.
+     * @return The [FrameColumn] these [KProperty Accessors][KProperty] point to.
+     */
+    public operator fun <T, R> KProperty<T>.get(column: KProperty<DataFrame<R>>): FrameColumn<R> =
+        invoke().asColumnGroup()[column]
+
+    /**
+     * Retrieves the value of the column with this name from the [DataFrame]. This can be
+     * both typed and untyped.
+     * This is a shorthand for [get][ColumnsContainer.get]`("myColumnName")` and can be
+     * written as `"myColumnName"<MyColumnType>()` instead.
+     *
+     * @throws [IllegalArgumentException] if there is no column with this name.
+     * @return The [DataColumn] with this name.
+     */
+    @Suppress("INAPPLICABLE_JVM_NAME")
+    @JvmName("stringInvokeTyped")
+    public operator fun <C> String.invoke(): DataColumn<C> = getColumn(this).cast()
+
+    /**
+     * Retrieves the value of the column with this name from the [DataFrame]. This can be
+     * both typed and untyped.
+     * This is a shorthand for [get][ColumnsContainer.get]`("myColumnName")` and can be
+     * written as `"myColumnName"()` instead.
+     *
+     * @throws [IllegalArgumentException] if there is no column with this name.
+     * @return The [DataColumn] with this name.
+     */
+    @Suppress("INAPPLICABLE_JVM_NAME")
+    @JvmName("stringInvokeUntyped")
+    public operator fun String.invoke(): DataColumn<*> = getColumn(this)
+
+    /**
+     * Creates a [ColumnPath] from the receiver and the given column name [column].
+     * This is a shorthand for [pathOf]`("myColumnName", "myNestedColumnName")` and is often used
+     * in combination with [ColumnPath.invoke] to retrieve the value of a nested column.
+     * For instance:
+     * ```kotlin
+     * "myColumn"["myNestedColumn"]<NestedColumnType>()
+     *
+     * "myColumn"["myNestedColumn"]["myDoublyNestedColumn"]<NestedColumnType>()
+     * ```
+     */
+    public operator fun String.get(column: String): ColumnPath = pathOf(this, column)
+
+    /**
+     * As extension to `"myColumn"["myNestedColumn"]`, this function enables
+     * `"myColumn"["myNestedColumn"]["myDoublyNestedColumn"]` as alternative to
+     * [pathOf]`("myColumn", "myNestedColumn", "myDoublyNestedColumn")`
+     */
+    public operator fun ColumnPath.get(column: String): ColumnPath = this + column
+}
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/ColumnsSelectionDsl.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/ColumnsSelectionDsl.kt
new file mode 100644
index 000000000..e78918dd1
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/ColumnsSelectionDsl.kt
@@ -0,0 +1,584 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import org.jetbrains.kotlinx.dataframe.ColumnsSelector
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.DataRow
+import org.jetbrains.kotlinx.dataframe.columns.ColumnPath
+import org.jetbrains.kotlinx.dataframe.columns.ColumnSet
+import org.jetbrains.kotlinx.dataframe.columns.ColumnsResolver
+import org.jetbrains.kotlinx.dataframe.columns.SingleColumn
+import kotlin.reflect.KProperty
+
+/** [Columns Selection DSL][ColumnsSelectionDsl] */
+internal interface ColumnsSelectionDslLink
+
+@Suppress("UNCHECKED_CAST")
+@PublishedApi
+internal fun <T> ColumnsSelectionDsl<T>.asSingleColumn(): SingleColumn<DataRow<T>> = this as SingleColumn<DataRow<T>>
+
+/**
+ * [DslMarker] for [ColumnsSelectionDsl] to prevent accessors being used across scopes for nested
+ * [ColumnsSelectionDsl.select] calls.
+ */
+@DslMarker
+@Target(AnnotationTarget.CLASS, AnnotationTarget.TYPEALIAS, AnnotationTarget.TYPE, AnnotationTarget.FUNCTION)
+public annotation class ColumnsSelectionDslMarker
+
+/**
+ * ## Columns Selection DSL
+ * Select or express columns using the [Columns Selection DSL][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl].
+ * (Any (combination of) [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+ *
+ * This DSL is initiated by a [Columns Selector][org.jetbrains.kotlinx.dataframe.ColumnsSelector] lambda,
+ * which operates in the context of the [Columns Selection DSL][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl] and
+ * expects you to return a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn] or [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] (so, a [ColumnsResolver][org.jetbrains.kotlinx.dataframe.columns.ColumnsResolver]).
+ * This is an entity formed by calling any (combination) of the functions
+ * in the DSL that is or can be resolved into one or more columns.
+ *
+ * #### NOTE:
+ * While you can use the [String API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi.StringApi] and [KProperties API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi.KPropertiesApi]
+ * in this DSL directly with any function, they are NOT valid return types for the
+ * [Columns Selector][org.jetbrains.kotlinx.dataframe.ColumnsSelector] lambda. You'd need to turn them into a [ColumnReference][org.jetbrains.kotlinx.dataframe.columns.ColumnReference] first, for instance
+ * with a function like [`col("name")`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.col].
+ *
+ * ### Check out: [Columns Selection DSL Grammar][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.DslGrammar]
+ *
+ * &nbsp;&nbsp;&nbsp;&nbsp;
+ *
+ * [See Column Selectors on the documentation website.](https://kotlin.github.io/dataframe/columnselectors.html)
+ *
+ * #### For example:
+ *
+ * `df.`[select][DataFrame.select]` { length `[and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]` age }`
+ *
+ * `df.`[select][DataFrame.select]`  {  `[cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`(1..5) }`
+ *
+ * `df.`[select][DataFrame.select]`  {  `[colsOf][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[Double][Double]`>() }`
+ *
+ *
+ *
+ *
+ */
+@ColumnsSelectionDslMarker
+public interface ColumnsSelectionDsl<out T> : // SingleColumn<DataRow<T>>
+    ColumnSelectionDsl<T>,
+    // first {}, firstCol()
+    FirstColumnsSelectionDsl,
+    // last {}, lastCol()
+    LastColumnsSelectionDsl,
+    // single {}, singleCol()
+    SingleColumnsSelectionDsl,
+    // col(name), col(5), [5]
+    ColColumnsSelectionDsl<T>,
+    // valueCol(name), valueCol(5)
+    ValueColColumnsSelectionDsl<T>,
+    // frameCol(name), frameCol(5)
+    FrameColColumnsSelectionDsl<T>,
+    // colGroup(name), colGroup(5)
+    ColGroupColumnsSelectionDsl<T>,
+    // cols {}, cols(), cols(colA, colB), cols(1, 5), cols(1..5), [{}]
+    ColsColumnsSelectionDsl<T>,
+    // colA.."colB"
+    ColumnRangeColumnsSelectionDsl,
+    // valueCols {}, valueCols()
+    ValueColsColumnsSelectionDsl,
+    // frameCols {}, frameCols()
+    FrameColsColumnsSelectionDsl,
+    // colGroups {}, colGroups()
+    ColGroupsColumnsSelectionDsl,
+    // colsOfKind(Value, Frame) {}, colsOfKind(Value, Frame)
+    ColsOfKindColumnsSelectionDsl,
+    // all(Cols), allAfter(colA), allBefore(colA), allFrom(colA), allUpTo(colA)
+    AllColumnsSelectionDsl<T>,
+    // colsAtAnyDepth {}, colsAtAnyDepth()
+    ColsAtAnyDepthColumnsSelectionDsl,
+    // colsInGroups {}, colsInGroups()
+    ColsInGroupsColumnsSelectionDsl,
+    // take(5), takeLastCols(2), takeLastWhile {}, takeColsWhile {}
+    TakeColumnsSelectionDsl,
+    // drop(5), dropLastCols(2), dropLastWhile {}, dropColsWhile {}
+    DropColumnsSelectionDsl,
+    // select {}, TODO due to String.invoke conflict this cannot be moved out of ColumnsSelectionDsl
+    SelectColumnsSelectionDsl,
+    // except(), allExcept {}, allColsExcept {}
+    AllExceptColumnsSelectionDsl,
+    // nameContains(""), colsNameContains(""), nameStartsWith(""), colsNameEndsWith("")
+    ColumnNameFiltersColumnsSelectionDsl,
+    // withoutNulls(), colsWithoutNulls()
+    WithoutNullsColumnsSelectionDsl,
+    // distinct()
+    DistinctColumnsSelectionDsl,
+    // none()
+    NoneColumnsSelectionDsl,
+    // colsOf<>(), colsOf<> {}
+    ColsOfColumnsSelectionDsl,
+    // simplify()
+    SimplifyColumnsSelectionDsl,
+    // filter {}
+    FilterColumnsSelectionDsl,
+    // colSet and colB
+    AndColumnsSelectionDsl,
+    // colA named "colB", colA into "colB"
+    RenameColumnsSelectionDsl,
+    // expr {}
+    ExprColumnsSelectionDsl {
+
+    /**
+     * ## [Columns Selection DSL][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl] Grammar
+     *
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * [(What is this notation?)][org.jetbrains.kotlinx.dataframe.documentation.DslGrammar]
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  ### Definitions:
+     *  `columnGroupReference: `[`String`][String]`  |  `[`KProperty`][kotlin.reflect.KProperty]`<*> | `[`ColumnPath`][org.jetbrains.kotlinx.dataframe.columns.ColumnPath]
+     *
+     * `colSelector: `[`ColumnSelector`][org.jetbrains.kotlinx.dataframe.ColumnSelector]
+     *
+     * `colsSelector: `[`ColumnsSelector`][org.jetbrains.kotlinx.dataframe.ColumnsSelector]
+     *
+     * `column: `[`ColumnAccessor`][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor]`  |  `[`String`][String]`  | `[`KProperty`][kotlin.reflect.KProperty]`<*> | `[`ColumnPath`][org.jetbrains.kotlinx.dataframe.columns.ColumnPath]
+     *
+     * `columnGroup: `[`SingleColumn`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]`<`[`DataRow`][org.jetbrains.kotlinx.dataframe.DataRow]`<*>> | `[`String`][String]`  |  `[`KProperty`][kotlin.reflect.KProperty]`<* | `[`DataRow`][org.jetbrains.kotlinx.dataframe.DataRow]`<*>> | `[`ColumnPath`][org.jetbrains.kotlinx.dataframe.columns.ColumnPath]
+     *
+     * `columnNoAccessor: `[`String`][String]`  |  `[`KProperty`][kotlin.reflect.KProperty]`<*> | `[`ColumnPath`][org.jetbrains.kotlinx.dataframe.columns.ColumnPath]
+     *
+     * `columnOrSet: `[`column`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ColumnDef]`  |  `[`columnSet`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ColumnSetDef]
+     *
+     * `columnSet: `[`ColumnSet`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]`<*>`
+     *
+     * `columnsResolver: `[`ColumnsResolver`][org.jetbrains.kotlinx.dataframe.columns.ColumnsResolver]
+     *
+     * `condition: `[`ColumnFilter`][org.jetbrains.kotlinx.dataframe.ColumnFilter]
+     *
+     * `expression: `[Column Expression][org.jetbrains.kotlinx.dataframe.documentation.ColumnExpression]
+     *
+     * `ignoreCase: `[`Boolean`][Boolean]
+     *
+     * `index: `[`Int`][Int]
+     *
+     * `indexRange: `[`IntRange`][IntRange]
+     *
+     * `infer: `[`Infer`][org.jetbrains.kotlinx.dataframe.api.Infer]
+     *
+     * `kind: `[`ColumnKind`][org.jetbrains.kotlinx.dataframe.columns.ColumnKind]
+     *
+     * `kType: `[`KType`][kotlin.reflect.KType]
+     *
+     * `name: `[`String`][String]
+     *
+     * `number: `[`Int`][Int]
+     *
+     * `regex: `[`Regex`][Regex]
+     *
+     * `singleColumn: `[`SingleColumn`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]`<`[`DataRow`][org.jetbrains.kotlinx.dataframe.DataRow]`<*>>`
+     *
+     * `T: Column type`
+     *
+     * `text: `[`String`][String]
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  ### What can be called directly in the [Columns Selection DSL][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl]:
+     *
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  [`column`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ColumnDef]` `[**`..`**][org.jetbrains.kotlinx.dataframe.api.ColumnRangeColumnsSelectionDsl.rangeTo]` `[`column`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ColumnDef]
+     *
+     * `| `**`this`**`/`**`it`**[**`[`**][cols][`column`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ColumnDef]**`,`**` .. `[**`]`**][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]
+     *
+     * `| `**`this`**`/`**`it`**[**`[`**][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]**`{ `**[`condition`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ConditionDef]**` }`**[**`]`**][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]
+     *
+     * `| `[**`all`**][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.all]**`()`**
+     *
+     * `| `**`all`**`(`[**`Before`**][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsBefore]`|`[**`After`**][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.allAfter]`|`[**`From`**][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsFrom]`|`[**`UpTo`**][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsUpTo]`) ( `**`(`**[`column`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ColumnDef]**`)`**` | `**`{ `**[`colSelector`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ColumnSelectorDef]**` }`**` )`
+     *
+     * `| `[**`allExcept`**][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.allExcept]**`  {  `**[`colsSelector`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ColumnsSelectorDef]**` }`**
+     *
+     * `| `[**`allExcept`**][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.allExcept]**`(`**[`column`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ColumnDef]**`,`**` ..`**`)`**
+     *
+     * `| `[`columnOrSet`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ColumnOrColumnSetDef]` `[**`and`**][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]`  [  `**`{`**`  ]  `[`columnOrSet`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ColumnOrColumnSetDef]`  [  `**`}`**`  ]  `
+     *
+     * `| `[`columnOrSet`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ColumnOrColumnSetDef]__`.`__[**`and`**][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]**` (`**`|`**`{ `**[`columnOrSet`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ColumnOrColumnSetDef]**` }`**`|`**`)`**
+     *
+     * `| (`[**`col`**][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.col]`| `[**`valueCol`**][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.valueCol]`| `[**`frameCol`**][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.frameCol]`| `[**`colGroup`**][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup]`)[`**`<`**[`T`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ColumnTypeDef]**`>`**`]`**`(`**[`column`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ColumnDef]`  |  `[`index`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.IndexDef]**`)`**
+     *
+     * `| (`[**`cols`**][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`| `[**`valueCols`**][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.valueCols]`| `[**`frameCols`**][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroups]`| `[**`colGroups`**][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroups]`) [ `**`{ `**[`condition`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ConditionDef]**` }`**` ]`
+     *
+     * `| `[**`cols`**][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`[`**`<`**[`T`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ColumnTypeDef]**`>`**`]`**`(`**[`column`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ColumnDef]**`,`**` .. | `[`index`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.IndexDef]**`,`**` .. | `[`indexRange`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.IndexRangeDef]**`)`**
+     *
+     * `| `[**`colsAtAnyDepth`**][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsAtAnyDepth]`  [  `**`{ `**[`condition`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ConditionDef]**` }`**` ]`
+     *
+     * `| `[**`colsInGroups`**][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsInGroups]`  [  `**`{ `**[`condition`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ConditionDef]**` }`**` ]`
+     *
+     * `| `[**colsOf**][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]**`<`**[`T`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ColumnTypeDef]**`>`**`  [  `**`(`**[`kType`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.KTypeDef]**`)`**`  ] [  `**`{ `**[`condition`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ConditionDef]**` }`**` ]`
+     *
+     * `| `[**`colsOfKind`**][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroups]**`(`**[`kind`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ColumnKindDef]**`,`**` ..`**`)`**`  [  `**`{ `**[`condition`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ConditionDef]**` }`**` ]`
+     *
+     * `| `[**`drop`**][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.drop]`(`[**`Last`**][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.dropLast]`)`**`(`**[`number`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.NumberDef]**`)`**
+     *
+     * `| `[**`drop`**][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.dropWhile]`(`[**`Last`**][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.dropLastWhile]`)`[**`While`**][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.dropWhile]**`  {  `**[`condition`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ConditionDef]**` }`**
+     *
+     * `| `[**`expr`**][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.expr]**`(`**`[`[`name`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.NameDef]**`,`**`][`[`infer`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.InferDef]`]`**`) { `**[`expression`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ColumnExpressionDef]**` }`**
+     *
+     * `| (`[**`first`**][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.first]`| `[**`last`**][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.last]`| `[**`single`**][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.single]`) [ `**`{ `**[`condition`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ConditionDef]**` }`**` ]`
+     *
+     * `| `[**`nameContains`**][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.nameContains]**`(`**[`text`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.TextDef]`[`**`, `**[`ignoreCase`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.IgnoreCaseDef]`] | `[`regex`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.RegexDef]**`)`**
+     *
+     * `| `__`name`__`(`[**`Starts`**][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.nameStartsWith]`|`[**`Ends`**][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.nameEndsWith]`)`**`With`**__`(`__[`text`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.TextDef]`[`**`, `**[`ignoreCase`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.IgnoreCaseDef]`]`**`)`**
+     *
+     * `| `[`column`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ColumnDef]` `[**named**][org.jetbrains.kotlinx.dataframe.api.RenameColumnsSelectionDsl.named]`/`[**into**][org.jetbrains.kotlinx.dataframe.api.RenameColumnsSelectionDsl.into]` `[`column`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ColumnDef]
+     *
+     * `| `[`column`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ColumnDef]`(`__`.`__[**named**][org.jetbrains.kotlinx.dataframe.api.RenameColumnsSelectionDsl.named]`|`__`.`__[**into**][org.jetbrains.kotlinx.dataframe.api.RenameColumnsSelectionDsl.into]`)`**`(`**[`column`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ColumnDef]**`)`**
+     *
+     * `| `[**`none`**][org.jetbrains.kotlinx.dataframe.api.NoneColumnsSelectionDsl.none]**`()`**
+     *
+     * `| `[**`take`**][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.take]`(`[**`Last`**][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.takeLast]`)`**`(`**[`number`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.NumberDef]**`)`**
+     *
+     * `| `[**`take`**][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.takeWhile]`(`[**`Last`**][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.takeLastWhile]`)`[**`While`**][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.takeWhile]**`  {  `**[`condition`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ConditionDef]**` }`**
+     *
+     * `| `[**`withoutNulls`**][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.withoutNulls]**`()`**
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  ### What can be called on a [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]:
+     *
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  [`columnSet`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ColumnSetDef]
+     *
+     *  &nbsp;&nbsp;&nbsp;&nbsp;[**`[`**][ColumnsSelectionDsl.col][`index`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.IndexDef][**`]`**][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.col]
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;`| `[**`[`**][cols][`index`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.IndexDef]**`,`**` .. | `[`indexRange`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.IndexRangeDef][**`]`**][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;`| `[**`[`**][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]**`{ `**[`condition`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ConditionDef]**` }`**[**`]`**][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;`| `__`.`__[**`all`**][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.all]**`()`**
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;`| `**`.all`**`(`[**`Before`**][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsBefore]`|`[**`After`**][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.allAfter]`|`[**`From`**][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsFrom]`|`[**`UpTo`**][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsUpTo]`) ( `**`(`**[`column`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ColumnDef]**`)`**`  |  `**`{ `**[`condition`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ConditionDef]**` }`**` )`
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;`| `__`.`__[**`and`**][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]**` (`**`|`**`{ `**[`columnOrSet`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ColumnOrColumnSetDef]**` }`**`|`**`)`**
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;`| (`__`.`__[**`col`**][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.col]`| `__`.`__[**`valueCol`**][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.valueCol]`| `__`.`__[**`frameCol`**][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.frameCol]`| `__`.`__[**`colGroup`**][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup]`)`**`(`**[`index`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.IndexDef]**`)`**
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;`| (`__`.`__[**`cols`**][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`| `__`.`__[**`valueCols`**][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.valueCols]`| `__`.`__[**`frameCols`**][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroups]`| `__`.`__[**`colGroups`**][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroups]`) [ `**`{ `**[`condition`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ConditionDef]**` }`**` ]`
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;`| `__`.`__[**`cols`**][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]**`(`**[`index`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.IndexDef]**`,`**` .. | `[`indexRange`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.IndexRangeDef]**`)`**
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;`| `__`.`__[**`colsAtAnyDepth`**][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsAtAnyDepth]`  [  `**`{ `**[`condition`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ConditionDef]**` }`**` ]`
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;`| `__`.`__[**`colsInGroups`**][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsInGroups]`  [  `**`{ `**[`condition`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ConditionDef]**` }`**` ]`
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;`| `__`.`__[**`colsOf`**][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]**`<`**[`T`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ColumnTypeDef]**`>`**`  [  `**`(`**[`kType`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.KTypeDef]**`)`**`  ] [  `**`{ `**[`condition`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ConditionDef]**` }`**` ]`
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;`| `__`.`__[**`colsOfKind`**][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroups]**`(`**[`kind`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ColumnKindDef]**`,`**` ..`**`)`**`  [  `**`{ `**[`condition`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ConditionDef]**` }`**` ]`
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;`| `__`.`__[**`distinct`**][org.jetbrains.kotlinx.dataframe.api.DistinctColumnsSelectionDsl.distinct]**`()`**
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;`| `__`.`__[**`drop`**][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.drop]`(`[**`Last`**][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.dropLast]`)`**`(`**[`number`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.NumberDef]**`)`**
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;`| `__`.`__[**`drop`**][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.dropWhile]`(`[**`Last`**][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.dropLastWhile]`)`[**`While`**][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.dropWhile]**`  {  `**[`condition`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ConditionDef]**` }`**
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;`| `[**`except`**][org.jetbrains.kotlinx.dataframe.api.AllExceptColumnsSelectionDsl.except]` [`**`  {  `**`] `[`columnsResolver`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ColumnsResolverDef]` [`**`  }  `**`]`
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;`| `[**`except`**][org.jetbrains.kotlinx.dataframe.api.AllExceptColumnsSelectionDsl.except]` `[`column`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ColumnDef]
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;`| `**`.`**[**`except`**][org.jetbrains.kotlinx.dataframe.api.AllExceptColumnsSelectionDsl.except]**`(`**[`column`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ColumnDef]**`,`**` ..`**`)`**
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;`| `__`.`__[**`filter`**][org.jetbrains.kotlinx.dataframe.api.FilterColumnsSelectionDsl.filter]**`  {  `**[`condition`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ConditionDef]**` }`**
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;`| (`__`.`__[**`first`**][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.first]`| `__`.`__[**`last`**][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.last]`| `__`.`__[**`single`**][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.single]`) [ `**`{ `**[`condition`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ConditionDef]**` }`**` ]`
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;`| `__`.name`__`(`[**`Starts`**][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.nameStartsWith]`|`[**`Ends`**][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.nameEndsWith]`)`**`With`**__`(`__[`text`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.TextDef]`[`**`, `**[`ignoreCase`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.IgnoreCaseDef]`]`**`)`**
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;`| `__`.`__[**`nameContains`**][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.nameContains]**`(`**[`text`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.TextDef]`[`**`, `**[`ignoreCase`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.IgnoreCaseDef]`] | `[`regex`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.RegexDef]**`)`**
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;`| `__`.`__[**`simplify`**][org.jetbrains.kotlinx.dataframe.api.SimplifyColumnsSelectionDsl.simplify]**`()`**
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;`| `__`.`__[**`take`**][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.take]`(`[**`Last`**][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.takeLast]`)`**`(`**[`number`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.NumberDef]**`)`**
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;`| `__`.`__[**`take`**][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.takeWhile]`(`[**`Last`**][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.takeLastWhile]`)`[**`While`**][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.takeWhile]**`  {  `**[`condition`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ConditionDef]**` }`**
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;`| `__`.`__[**`withoutNulls`**][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.withoutNulls]**`()`**
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  ### What can be called on a [Column Group (reference)][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ColumnGroupDef]:
+     *
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  [`columnGroup`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ColumnGroupDef]
+     *
+     *  &nbsp;&nbsp;&nbsp;&nbsp;`| `[**`[`**][cols][`column`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ColumnDef]**`,`**` ..`[**`]`**][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;`| `[**`[`**][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]**`{ `**[`condition`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ConditionDef]**` }`**[**`]`**][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;`| `[**`{`**][org.jetbrains.kotlinx.dataframe.api.SelectColumnsSelectionDsl.select]` `[`colsSelector`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ColumnsSelectorDef]` `[**`}`**][org.jetbrains.kotlinx.dataframe.api.SelectColumnsSelectionDsl.select]
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;`| `__`.`__[**`allCols`**][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allCols]**`()`**
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;`| `**`.allCols`**`(`[**`Before`**][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsBefore]`|`[**`After`**][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.allAfter]`|`[**`From`**][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsFrom]`|`[**`UpTo`**][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsUpTo]`) ( `**`(`**[`column`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ColumnDef]**`)`**`  |  `**`{ `**[`colSelector`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ColumnSelectorDef]**` }`**` )`
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;`| `__`.`__[**`allColsExcept`**][org.jetbrains.kotlinx.dataframe.api.AllExceptColumnsSelectionDsl.allColsExcept]**`  {  `**[`colsSelector`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ColumnsSelectorDef]**`  }  `**
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;`| `__`.`__[**`allColsExcept`**][org.jetbrains.kotlinx.dataframe.api.AllExceptColumnsSelectionDsl.allColsExcept]**`(`**[`columnNoAccessor`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ColumnNoAccessorDef]**`,`**` ..`**`)`**
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;`| `__`.`__[**`and`**][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]**` (`**`|`**`{ `**[`columnOrSet`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ColumnOrColumnSetDef]**` }`**`|`**`)`**
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;`| (`__`.`__[**`col`**][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.col]`| `__`.`__[**`valueCol`**][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.valueCol]`| `__`.`__[**`frameCol`**][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.frameCol]`| `__`.`__[**`colGroup`**][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup]`)[`**`<`**[`T`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ColumnTypeDef]**`>`**`]`**`(`**[`column`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ColumnDef]`  |  `[`index`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.IndexDef]**`)`**
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;`| (`__`.`__[**`cols`**][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`| `__`.`__[**`valueCols`**][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.valueCols]`| `__`.`__[**`frameCols`**][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroups]`| `__`.`__[**`colGroups`**][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroups]`) [ `**`{ `**[`condition`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ConditionDef]**` }`**` ]`
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;`| `__`.`__[**`cols`**][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`[`**`<`**[`T`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ColumnTypeDef]**`>`**`]`**`(`**[`column`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ColumnDef]**`,`**` .. | `[`index`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.IndexDef]**`,`**` .. | `[`indexRange`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.IndexRangeDef]**`)`**
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;`| `__`.`__[**`colsAtAnyDepth`**][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsAtAnyDepth]`  [  `**`{ `**[`condition`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ConditionDef]**` }`**` ]`
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;`| `__`.`__[**`colsInGroups`**][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsInGroups]`  [  `**`{ `**[`condition`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ConditionDef]**` }`**` ]`
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;`| `__`.colsName`__`(`[**`Starts`**][org.jetbrains.kotlinx.dataframe.api.ColumnNameFiltersColumnsSelectionDsl.colsNameStartsWith]`|`[**`Ends`**][org.jetbrains.kotlinx.dataframe.api.ColumnNameFiltersColumnsSelectionDsl.colsNameEndsWith]`)`**`With`**__`(`__[`text`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.TextDef]`[`**`, `**[`ignoreCase`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.IgnoreCaseDef]`]`**`)`**
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;`| `__`.`__[**`colsNameContains`**][org.jetbrains.kotlinx.dataframe.api.ColumnNameFiltersColumnsSelectionDsl.colsNameContains]**`(`**[`text`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.TextDef]`[`**`, `**[`ignoreCase`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.IgnoreCaseDef]`] | `[`regex`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.RegexDef]**`)`**
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;`| `__`.`__[**`colsOfKind`**][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroups]**`(`**[`kind`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ColumnKindDef]**`,`**` ..`**`)`**`  [  `**`{ `**[`condition`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ConditionDef]**` }`**` ]`
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;`| `__`.`__[**`colsWithoutNulls`**][org.jetbrains.kotlinx.dataframe.api.WithoutNullsColumnsSelectionDsl.colsWithoutNulls]**`()`**
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;`| `__`.`__[**`drop`**][org.jetbrains.kotlinx.dataframe.api.DropColumnsSelectionDsl.dropCols]`(`[**`Last`**][org.jetbrains.kotlinx.dataframe.api.DropColumnsSelectionDsl.dropLastCols]`)`[**`Cols`**][org.jetbrains.kotlinx.dataframe.api.DropColumnsSelectionDsl.dropCols]**`(`**[`number`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.NumberDef]**`)`**
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;`| `__`.`__[**`drop`**][org.jetbrains.kotlinx.dataframe.api.DropColumnsSelectionDsl.dropColsWhile]`(`[**`Last`**][org.jetbrains.kotlinx.dataframe.api.DropColumnsSelectionDsl.dropLastColsWhile]`)`[**`ColsWhile`**][org.jetbrains.kotlinx.dataframe.api.DropColumnsSelectionDsl.dropColsWhile]**`  {  `**[`condition`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ConditionDef]**` }`**
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;`| `[**`exceptNew`**][org.jetbrains.kotlinx.dataframe.api.AllExceptColumnsSelectionDsl.exceptNew]**`  {  `**[`colsSelector`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ColumnsSelectorDef]**` } EXPERIMENTAL!`**
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;`| `[**`exceptNew`**][org.jetbrains.kotlinx.dataframe.api.AllExceptColumnsSelectionDsl.exceptNew]**`(`**[`columnNoAccessor`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ColumnNoAccessorDef]**`,`**` ..`**`) EXPERIMENTAL!`**
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;`| (`__`.`__[**`firstCol`**][org.jetbrains.kotlinx.dataframe.api.FirstColumnsSelectionDsl.firstCol]`| `__`.`__[**`lastCol`**][org.jetbrains.kotlinx.dataframe.api.LastColumnsSelectionDsl.lastCol]`| `__`.`__[**`singleCol`**][org.jetbrains.kotlinx.dataframe.api.SingleColumnsSelectionDsl.singleCol]`) [ `**`{ `**[`condition`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ConditionDef]**` }`**` ]`
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;`| `__`.`__[**`select`**][org.jetbrains.kotlinx.dataframe.api.SelectColumnsSelectionDsl.select]**`  {  `**[`colsSelector`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ColumnsSelectorDef]**` }`**
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;`| `__`.`__[**`take`**][org.jetbrains.kotlinx.dataframe.api.TakeColumnsSelectionDsl.takeCols]`(`[**`Last`**][org.jetbrains.kotlinx.dataframe.api.TakeColumnsSelectionDsl.takeLastCols]`)`[**`Cols`**][org.jetbrains.kotlinx.dataframe.api.TakeColumnsSelectionDsl.takeCols]**`(`**[`number`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.NumberDef]**`)`**
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;`| `__`.`__[**`take`**][org.jetbrains.kotlinx.dataframe.api.TakeColumnsSelectionDsl.takeColsWhile]`(`[**`Last`**][org.jetbrains.kotlinx.dataframe.api.TakeColumnsSelectionDsl.takeLastColsWhile]`)`[**`ColsWhile`**][org.jetbrains.kotlinx.dataframe.api.TakeColumnsSelectionDsl.takeColsWhile]**`  {  `**[`condition`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ConditionDef]**` }`**
+     *
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     * [`singleColumn`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.SingleColumnDef]
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;__`.`__[**`colsOf`**][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]**`<`**[`T`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ColumnTypeDef]**`>`**`  [  `**`(`**[`kType`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.KTypeDef]**`)`**`  ] [  `**`{ `**[`condition`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ConditionDef]**` }`**` ]`
+     *
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     * [`columnGroupReference`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ColumnGroupNoSingleColumnDef]
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;__`.`__[**`colsOf`**][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]**`<`**[`T`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ColumnTypeDef]**`>(`**[`kType`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.KTypeDef]**`)`**`  [  `**`{ `**[`condition`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ConditionDef]**` }`**` ]`
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     */
+    public interface DslGrammar
+
+    /**
+     * Invokes the given [ColumnsSelector] using this [ColumnsSelectionDsl].
+     */
+    public operator fun <C> ColumnsSelector<T, C>.invoke(): ColumnsResolver<C> =
+        this@invoke(this@ColumnsSelectionDsl, this@ColumnsSelectionDsl)
+
+    // region select
+    // NOTE: due to invoke conflicts these cannot be moved out of the interface
+
+    /**
+     * ## Select from [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup]
+     *
+     * Perform a selection of columns using the [Columns Selection DSL][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl] on
+     * any [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup]. This is more powerful than the [cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols] filter, because now all
+     * operations of the DSL are at your disposal.
+     *
+     * The scope of the new DSL instance is relative to
+     * the [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup] you are selecting from.
+     *
+     * The [invoke][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.invoke] operator is overloaded to work as a shortcut for this method.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.SelectColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColGroup.`[select][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.select]`  { someCol  `[and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]` `[colsOf][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.colsOf]`<`[String][String]`>() } }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  { "myGroupCol"  `[{][kotlin.String.select]`  "colA" and  `[expr][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.expr]`  { 0 }  `[}][kotlin.String.select]` }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "pathTo"["myGroupCol"].`[select][org.jetbrains.kotlinx.dataframe.columns.ColumnPath.select]` { "colA" and "colB" } }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { it["myGroupCol"].`[asColumnGroup][org.jetbrains.kotlinx.dataframe.DataColumn.asColumnGroup]`()`[() {][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.select]`  "colA" and "colB"  `[}][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.select]` }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][DataFrame.select]` { myColGroup.`[`select`][SingleColumn.select]`  { someCol  `[`and`][ColumnsSelectionDsl.and]` `[`colsOf`][SingleColumn.colsOf]`<`[`String`][String]`>() } }`
+     *
+     * `df.`[select][DataFrame.select]`  { myColGroup  `[`{`][SingleColumn.select]`  colA  `[and][ColumnsSelectionDsl.and]`  colB  `[`}`][SingleColumn.select]` }`
+     *
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     * See also [except][org.jetbrains.kotlinx.dataframe.api.AllExceptColumnsSelectionDsl.except]/[allExcept][org.jetbrains.kotlinx.dataframe.api.AllExceptColumnsSelectionDsl.allColsExcept] for the inverted operation of this function.
+     *
+     * @param [selector] The [ColumnsSelector][org.jetbrains.kotlinx.dataframe.ColumnsSelector] to use for the selection.
+     * @receiver The [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup] to select from.
+     * @throws [IllegalArgumentException] If [this] is not a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing the columns selected by [selector].
+     * @see [SingleColumn.except]
+     */
+    public operator fun <C, R> SingleColumn<DataRow<C>>.invoke(selector: ColumnsSelector<C, R>): ColumnSet<R> =
+        select(selector)
+
+    /**
+     * ## Select from [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup]
+     *
+     * Perform a selection of columns using the [Columns Selection DSL][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl] on
+     * any [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup]. This is more powerful than the [cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols] filter, because now all
+     * operations of the DSL are at your disposal.
+     *
+     * The scope of the new DSL instance is relative to
+     * the [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup] you are selecting from.
+     *
+     * The [invoke][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.invoke] operator is overloaded to work as a shortcut for this method.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.SelectColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColGroup.`[select][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.select]`  { someCol  `[and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]` `[colsOf][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.colsOf]`<`[String][String]`>() } }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  { "myGroupCol"  `[{][kotlin.String.select]`  "colA" and  `[expr][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.expr]`  { 0 }  `[}][kotlin.String.select]` }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "pathTo"["myGroupCol"].`[select][org.jetbrains.kotlinx.dataframe.columns.ColumnPath.select]` { "colA" and "colB" } }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { it["myGroupCol"].`[asColumnGroup][org.jetbrains.kotlinx.dataframe.DataColumn.asColumnGroup]`()`[() {][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.select]`  "colA" and "colB"  `[}][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.select]` }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][DataFrame.select]` { Type::myColGroup.`[`select`][KProperty.select]`  { someCol  `[`and`][ColumnsSelectionDsl.and]` `[`colsOf`][SingleColumn.colsOf]`<`[`String`][String]`>() } }`
+     *
+     * `df.`[select][DataFrame.select]`  { DataSchemaType::myColGroup  `[`{`][KProperty.select]`  colA  `[`and`][ColumnsSelectionDsl.and]`  colB  `[`}`][KProperty.select]` }`
+     *
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     * See also [except][org.jetbrains.kotlinx.dataframe.api.AllExceptColumnsSelectionDsl.except]/[allExcept][org.jetbrains.kotlinx.dataframe.api.AllExceptColumnsSelectionDsl.allColsExcept] for the inverted operation of this function.
+     *
+     * @param [selector] The [ColumnsSelector][org.jetbrains.kotlinx.dataframe.ColumnsSelector] to use for the selection.
+     * @receiver The [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup] to select from.
+     * @throws [IllegalArgumentException] If [this] is not a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing the columns selected by [selector].
+     * @see [SingleColumn.except]
+     */
+    public operator fun <C, R> KProperty<C>.invoke(selector: ColumnsSelector<C, R>): ColumnSet<R> =
+        columnGroup(this).select(selector)
+
+    /**
+     * ## Select from [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup]
+     *
+     * Perform a selection of columns using the [Columns Selection DSL][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl] on
+     * any [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup]. This is more powerful than the [cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols] filter, because now all
+     * operations of the DSL are at your disposal.
+     *
+     * The scope of the new DSL instance is relative to
+     * the [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup] you are selecting from.
+     *
+     * The [invoke][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.invoke] operator is overloaded to work as a shortcut for this method.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.SelectColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColGroup.`[select][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.select]`  { someCol  `[and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]` `[colsOf][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.colsOf]`<`[String][String]`>() } }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  { "myGroupCol"  `[{][kotlin.String.select]`  "colA" and  `[expr][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.expr]`  { 0 }  `[}][kotlin.String.select]` }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "pathTo"["myGroupCol"].`[select][org.jetbrains.kotlinx.dataframe.columns.ColumnPath.select]` { "colA" and "colB" } }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { it["myGroupCol"].`[asColumnGroup][org.jetbrains.kotlinx.dataframe.DataColumn.asColumnGroup]`()`[() {][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.select]`  "colA" and "colB"  `[}][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.select]` }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][DataFrame.select]` { "myColGroup".`[`select`][String.select]`  { someCol  `[`and`][ColumnsSelectionDsl.and]` `[`colsOf`][SingleColumn.colsOf]`<`[`String`][String]`>() } }`
+     *
+     * `df.`[select][DataFrame.select]`  { "myColGroup"  `[`{`][String.select]`  colA  `[`and`][ColumnsSelectionDsl.and]`  colB  `[`}`][String.select]` }`
+     *
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     * See also [except][org.jetbrains.kotlinx.dataframe.api.AllExceptColumnsSelectionDsl.except]/[allExcept][org.jetbrains.kotlinx.dataframe.api.AllExceptColumnsSelectionDsl.allColsExcept] for the inverted operation of this function.
+     *
+     * @param [selector] The [ColumnsSelector][org.jetbrains.kotlinx.dataframe.ColumnsSelector] to use for the selection.
+     * @receiver The [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup] to select from.
+     * @throws [IllegalArgumentException] If [this] is not a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing the columns selected by [selector].
+     * @see [SingleColumn.except]
+     */
+    public operator fun <R> String.invoke(selector: ColumnsSelector<*, R>): ColumnSet<R> = select(selector)
+
+    /**
+     * ## Select from [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup]
+     *
+     * Perform a selection of columns using the [Columns Selection DSL][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl] on
+     * any [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup]. This is more powerful than the [cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols] filter, because now all
+     * operations of the DSL are at your disposal.
+     *
+     * The scope of the new DSL instance is relative to
+     * the [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup] you are selecting from.
+     *
+     * The [invoke][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.invoke] operator is overloaded to work as a shortcut for this method.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.SelectColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColGroup.`[select][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.select]`  { someCol  `[and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]` `[colsOf][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.colsOf]`<`[String][String]`>() } }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  { "myGroupCol"  `[{][kotlin.String.select]`  "colA" and  `[expr][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.expr]`  { 0 }  `[}][kotlin.String.select]` }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "pathTo"["myGroupCol"].`[select][org.jetbrains.kotlinx.dataframe.columns.ColumnPath.select]` { "colA" and "colB" } }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { it["myGroupCol"].`[asColumnGroup][org.jetbrains.kotlinx.dataframe.DataColumn.asColumnGroup]`()`[() {][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.select]`  "colA" and "colB"  `[}][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.select]` }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][DataFrame.select]` { "pathTo"["myColGroup"].`[`select`][ColumnPath.select]`  { someCol  `[`and`][ColumnsSelectionDsl.and]` `[`colsOf`][SingleColumn.colsOf]`<`[`String`][String]`>() } }`
+     *
+     * `df.`[select][DataFrame.select]`  { "pathTo"["myColGroup"]  `[`{`][ColumnPath.select]`  colA  `[`and`][ColumnsSelectionDsl.and]`  colB  `[`}`][ColumnPath.select]` }`
+     *
+     * `df.`[select][DataFrame.select]`  {  `[`pathOf`][pathOf]`("pathTo", "myColGroup").`[`select`][ColumnPath.select]`  { someCol  `[`and`][ColumnsSelectionDsl.and]` `[`colsOf`][SingleColumn.colsOf]`<`[`String`][String]`>() } }`
+     *
+     * `df.`[select][DataFrame.select]`  {  `[`pathOf`][pathOf]`("pathTo", "myColGroup")`[`() {`][ColumnPath.select]`  someCol  `[`and`][ColumnsSelectionDsl.and]` `[`colsOf`][SingleColumn.colsOf]`<`[`String`][String]`>() `[`}`][ColumnPath.select]` }`
+     *
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     * See also [except][org.jetbrains.kotlinx.dataframe.api.AllExceptColumnsSelectionDsl.except]/[allExcept][org.jetbrains.kotlinx.dataframe.api.AllExceptColumnsSelectionDsl.allColsExcept] for the inverted operation of this function.
+     *
+     * @param [selector] The [ColumnsSelector][org.jetbrains.kotlinx.dataframe.ColumnsSelector] to use for the selection.
+     * @receiver The [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup] to select from.
+     * @throws [IllegalArgumentException] If [this] is not a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing the columns selected by [selector].
+     * @see [SingleColumn.except]
+     */
+    public operator fun <R> ColumnPath.invoke(selector: ColumnsSelector<*, R>): ColumnSet<R> = select(selector)
+
+    // endregion
+}
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/DataColumnArithmetics.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/DataColumnArithmetics.kt
new file mode 100644
index 000000000..6879c8acc
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/DataColumnArithmetics.kt
@@ -0,0 +1,180 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import org.jetbrains.kotlinx.dataframe.AnyCol
+import org.jetbrains.kotlinx.dataframe.DataColumn
+import org.jetbrains.kotlinx.dataframe.Predicate
+import org.jetbrains.kotlinx.dataframe.columns.ColumnReference
+import java.math.BigDecimal
+
+public operator fun DataColumn<Boolean>.not(): DataColumn<Boolean> = map { !it }
+
+@JvmName("notBooleanNullable")
+public operator fun DataColumn<Boolean?>.not(): DataColumn<Boolean?> = map { it?.not() }
+
+public operator fun ColumnReference<Boolean>.not(): ColumnReference<Boolean> = map { !it }
+
+@JvmName("notBooleanNullable")
+public operator fun ColumnReference<Boolean?>.not(): ColumnReference<Boolean?> = map { it?.not() }
+
+public operator fun DataColumn<Int>.plus(value: Int): DataColumn<Int> = map { it + value }
+
+public operator fun DataColumn<Int>.minus(value: Int): DataColumn<Int> = map { it - value }
+
+public operator fun Int.plus(column: DataColumn<Int>): DataColumn<Int> = column.map { this + it }
+
+public operator fun Int.minus(column: DataColumn<Int>): DataColumn<Int> = column.map { this - it }
+
+public operator fun DataColumn<Int>.unaryMinus(): DataColumn<Int> = map { -it }
+
+public operator fun DataColumn<Int>.times(value: Int): DataColumn<Int> = map { it * value }
+
+public operator fun DataColumn<Int>.div(value: Int): DataColumn<Int> = map { it / value }
+
+public operator fun Int.div(column: DataColumn<Int>): DataColumn<Int> = column.map { this / it }
+
+public operator fun AnyCol.plus(str: String): DataColumn<String> = map { it.toString() + str }
+
+public operator fun ColumnReference<Int>.plus(value: Int): ColumnReference<Int> = map { it + value }
+
+public operator fun ColumnReference<Int>.minus(value: Int): ColumnReference<Int> = map { it - value }
+
+public operator fun Int.plus(column: ColumnReference<Int>): ColumnReference<Int> = column.map { this + it }
+
+public operator fun Int.minus(column: ColumnReference<Int>): ColumnReference<Int> = column.map { this - it }
+
+public operator fun ColumnReference<Int>.unaryMinus(): ColumnReference<Int> = map { -it }
+
+public operator fun ColumnReference<Int>.times(value: Int): ColumnReference<Int> = map { it * value }
+
+public operator fun ColumnReference<Int>.div(value: Int): ColumnReference<Int> = map { it / value }
+
+public operator fun Int.div(column: ColumnReference<Int>): ColumnReference<Int> = column.map { this / it }
+
+public operator fun ColumnReference<Any?>.plus(str: String): ColumnReference<String> = map { it.toString() + str }
+
+@JvmName("plusIntNullable")
+public operator fun DataColumn<Int?>.plus(value: Int): DataColumn<Int?> = map { it?.plus(value) }
+
+@JvmName("minusIntNullable")
+public operator fun DataColumn<Int?>.minus(value: Int): DataColumn<Int?> = map { it?.minus(value) }
+
+@JvmName("plusNullable")
+public operator fun Int.plus(column: DataColumn<Int?>): DataColumn<Int?> = column.map { it?.plus(this) }
+
+@JvmName("minusNullable")
+public operator fun Int.minus(column: DataColumn<Int?>): DataColumn<Int?> = column.map { it?.let { this - it } }
+
+@JvmName("unaryMinusIntNullable")
+public operator fun DataColumn<Int?>.unaryMinus(): DataColumn<Int?> = map { it?.unaryMinus() }
+
+@JvmName("timesIntNullable")
+public operator fun DataColumn<Int?>.times(value: Int): DataColumn<Int?> = map { it?.times(value) }
+
+@JvmName("divIntNullable")
+public operator fun DataColumn<Int?>.div(value: Int): DataColumn<Int?> = map { it?.div(value) }
+
+@JvmName("divNullable")
+public operator fun Int.div(column: DataColumn<Int?>): DataColumn<Int?> = column.map { it?.let { this / it } }
+
+@JvmName("plusInt")
+public operator fun DataColumn<Int>.plus(value: Double): DataColumn<Double> = map { it + value }
+
+@JvmName("minusInt")
+public operator fun DataColumn<Int>.minus(value: Double): DataColumn<Double> = map { it - value }
+
+@JvmName("doublePlus")
+public operator fun Double.plus(column: DataColumn<Int>): DataColumn<Double> = column.map { this + it }
+
+@JvmName("doubleMinus")
+public operator fun Double.minus(column: DataColumn<Int>): DataColumn<Double> = column.map { this - it }
+
+@JvmName("timesInt")
+public operator fun DataColumn<Int>.times(value: Double): DataColumn<Double> = map { it * value }
+
+@JvmName("divInt")
+public operator fun DataColumn<Int>.div(value: Double): DataColumn<Double> = map { it / value }
+
+@JvmName("doubleDiv")
+public operator fun Double.div(column: DataColumn<Int>): DataColumn<Double> = column.map { this / it }
+
+@JvmName("plusDouble")
+public operator fun DataColumn<Double>.plus(value: Int): DataColumn<Double> = map { it + value }
+
+@JvmName("minusDouble")
+public operator fun DataColumn<Double>.minus(value: Int): DataColumn<Double> = map { it - value }
+
+@JvmName("intPlus")
+public operator fun Int.plus(column: DataColumn<Double>): DataColumn<Double> = column.map { this + it }
+
+@JvmName("intMinus")
+public operator fun Int.minus(column: DataColumn<Double>): DataColumn<Double> = column.map { this - it }
+
+@JvmName("timesDouble")
+public operator fun DataColumn<Double>.times(value: Int): DataColumn<Double> = map { it * value }
+
+@JvmName("divDouble")
+public operator fun DataColumn<Double>.div(value: Int): DataColumn<Double> = map { it / value }
+
+@JvmName("intDiv")
+public operator fun Int.div(column: DataColumn<Double>): DataColumn<Double> = column.map { this / it }
+
+public operator fun DataColumn<Double>.plus(value: Double): DataColumn<Double> = map { it + value }
+
+public operator fun DataColumn<Double>.minus(value: Double): DataColumn<Double> = map { it - value }
+
+public operator fun Double.plus(column: DataColumn<Double>): DataColumn<Double> = column.map { this + it }
+
+public operator fun Double.minus(column: DataColumn<Double>): DataColumn<Double> = column.map { this - it }
+
+@JvmName("unaryMinusDouble")
+public operator fun DataColumn<Double>.unaryMinus(): DataColumn<Double> = map { -it }
+
+public operator fun DataColumn<Double>.times(value: Double): DataColumn<Double> = map { it * value }
+
+public operator fun DataColumn<Double>.div(value: Double): DataColumn<Double> = map { it / value }
+
+public operator fun Double.div(column: DataColumn<Double>): DataColumn<Double> = column.map { this / it }
+
+public operator fun DataColumn<Long>.plus(value: Long): DataColumn<Long> = map { it + value }
+
+public operator fun DataColumn<Long>.minus(value: Long): DataColumn<Long> = map { it - value }
+
+public operator fun Long.plus(column: DataColumn<Long>): DataColumn<Long> = column.map { this + it }
+
+public operator fun Long.minus(column: DataColumn<Long>): DataColumn<Long> = column.map { this - it }
+
+@JvmName("unaryMinusLong")
+public operator fun DataColumn<Long>.unaryMinus(): DataColumn<Long> = map { -it }
+
+public operator fun DataColumn<Long>.times(value: Long): DataColumn<Long> = map { it * value }
+
+public operator fun DataColumn<Long>.div(value: Long): DataColumn<Long> = map { it / value }
+
+public operator fun Long.div(column: DataColumn<Long>): DataColumn<Long> = column.map { this / it }
+
+public operator fun DataColumn<BigDecimal>.plus(value: BigDecimal): DataColumn<BigDecimal> = map { it + value }
+
+public operator fun DataColumn<BigDecimal>.minus(value: BigDecimal): DataColumn<BigDecimal> = map { it - value }
+
+public operator fun BigDecimal.plus(column: DataColumn<BigDecimal>): DataColumn<BigDecimal> = column.map { this + it }
+
+public operator fun BigDecimal.minus(column: DataColumn<BigDecimal>): DataColumn<BigDecimal> = column.map { this - it }
+
+@JvmName("unaryMinusBigDecimal")
+public operator fun DataColumn<BigDecimal>.unaryMinus(): DataColumn<BigDecimal> = map { -it }
+
+public operator fun DataColumn<BigDecimal>.times(value: BigDecimal): DataColumn<BigDecimal> = map { it * value }
+
+public operator fun DataColumn<BigDecimal>.div(value: BigDecimal): DataColumn<BigDecimal> = map { it / value }
+
+public operator fun BigDecimal.div(column: DataColumn<BigDecimal>): DataColumn<BigDecimal> = column.map { this / it }
+
+public infix fun <T> DataColumn<T>.eq(value: T): DataColumn<Boolean> = isMatching { it == value }
+
+public infix fun <T> DataColumn<T>.neq(value: T): DataColumn<Boolean> = isMatching { it != value }
+
+public infix fun <T : Comparable<T>> DataColumn<T>.gt(value: T): DataColumn<Boolean> = isMatching { it > value }
+
+public infix fun <T : Comparable<T>> DataColumn<T>.lt(value: T): DataColumn<Boolean> = isMatching { it < value }
+
+internal fun <T> DataColumn<T>.isMatching(predicate: Predicate<T>): DataColumn<Boolean> = map { predicate(it) }
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/DataColumnType.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/DataColumnType.kt
new file mode 100644
index 000000000..2c7887ab3
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/DataColumnType.kt
@@ -0,0 +1,68 @@
+@file:OptIn(ExperimentalContracts::class)
+
+package org.jetbrains.kotlinx.dataframe.api
+
+import org.jetbrains.kotlinx.dataframe.AnyCol
+import org.jetbrains.kotlinx.dataframe.columns.ColumnGroup
+import org.jetbrains.kotlinx.dataframe.columns.ColumnKind
+import org.jetbrains.kotlinx.dataframe.columns.FrameColumn
+import org.jetbrains.kotlinx.dataframe.columns.ValueColumn
+import org.jetbrains.kotlinx.dataframe.impl.isNothing
+import org.jetbrains.kotlinx.dataframe.impl.projectTo
+import org.jetbrains.kotlinx.dataframe.type
+import org.jetbrains.kotlinx.dataframe.typeClass
+import kotlin.contracts.ExperimentalContracts
+import kotlin.contracts.contract
+import kotlin.reflect.KClass
+import kotlin.reflect.KType
+import kotlin.reflect.KTypeProjection
+import kotlin.reflect.full.isSubclassOf
+import kotlin.reflect.full.isSubtypeOf
+import kotlin.reflect.typeOf
+
+public fun AnyCol.isColumnGroup(): Boolean {
+    contract { returns(true) implies (this@isColumnGroup is ColumnGroup<*>) }
+    return kind() == ColumnKind.Group
+}
+
+public fun AnyCol.isFrameColumn(): Boolean {
+    contract { returns(true) implies (this@isFrameColumn is FrameColumn<*>) }
+    return kind() == ColumnKind.Frame
+}
+
+public fun AnyCol.isValueColumn(): Boolean {
+    contract { returns(true) implies (this@isValueColumn is ValueColumn<*>) }
+    return kind() == ColumnKind.Value
+}
+
+public fun AnyCol.isSubtypeOf(type: KType): Boolean =
+    this.type.isSubtypeOf(type) && (!this.type.isMarkedNullable || type.isMarkedNullable)
+
+public inline fun <reified T> AnyCol.isSubtypeOf(): Boolean = isSubtypeOf(typeOf<T>())
+
+public inline fun <reified T> AnyCol.isType(): Boolean = type() == typeOf<T>()
+
+public fun AnyCol.isNumber(): Boolean = isSubtypeOf<Number?>()
+
+public fun AnyCol.isList(): Boolean = typeClass == List::class
+
+/**
+ * Returns `true` if [this] column is comparable, i.e. its type is a subtype of [Comparable] and its
+ * type argument is not [Nothing].
+ */
+public fun AnyCol.isComparable(): Boolean =
+    isSubtypeOf<Comparable<*>?>() &&
+        type().projectTo(Comparable::class).arguments[0].let {
+            it != KTypeProjection.STAR &&
+                it.type?.isNothing != true
+        }
+
+@PublishedApi
+internal fun AnyCol.isPrimitive(): Boolean = typeClass.isPrimitive()
+
+internal fun KClass<*>.isPrimitive(): Boolean =
+    isSubclassOf(Number::class) ||
+        this == String::class ||
+        this == Char::class ||
+        this == Array::class ||
+        isSubclassOf(Collection::class)
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/DataFrameGet.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/DataFrameGet.kt
new file mode 100644
index 000000000..c5322aa2e
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/DataFrameGet.kt
@@ -0,0 +1,155 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import org.jetbrains.kotlinx.dataframe.AnyCol
+import org.jetbrains.kotlinx.dataframe.AnyColumnReference
+import org.jetbrains.kotlinx.dataframe.ColumnSelector
+import org.jetbrains.kotlinx.dataframe.ColumnsContainer
+import org.jetbrains.kotlinx.dataframe.ColumnsSelector
+import org.jetbrains.kotlinx.dataframe.DataColumn
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.DataRow
+import org.jetbrains.kotlinx.dataframe.columns.ColumnGroup
+import org.jetbrains.kotlinx.dataframe.columns.ColumnPath
+import org.jetbrains.kotlinx.dataframe.columns.ColumnReference
+import org.jetbrains.kotlinx.dataframe.columns.ColumnWithPath
+import org.jetbrains.kotlinx.dataframe.columns.FrameColumn
+import org.jetbrains.kotlinx.dataframe.columns.UnresolvedColumnsPolicy
+import org.jetbrains.kotlinx.dataframe.columns.toColumnSet
+import org.jetbrains.kotlinx.dataframe.impl.columnName
+import org.jetbrains.kotlinx.dataframe.impl.columns.asAnyFrameColumn
+import org.jetbrains.kotlinx.dataframe.impl.getColumnPaths
+import org.jetbrains.kotlinx.dataframe.impl.getColumnsWithPaths
+import org.jetbrains.kotlinx.dataframe.ncol
+import org.jetbrains.kotlinx.dataframe.nrow
+import kotlin.reflect.KProperty
+
+public fun <T, C> DataFrame<T>.getColumnsWithPaths(selector: ColumnsSelector<T, C>): List<ColumnWithPath<C>> =
+    getColumnsWithPaths(UnresolvedColumnsPolicy.Fail, selector)
+
+public fun <T, C> DataFrame<T>.getColumnPath(selector: ColumnSelector<T, C>): ColumnPath =
+    getColumnPaths(selector).single()
+
+public fun <T, C> DataFrame<T>.getColumnPaths(selector: ColumnsSelector<T, C>): List<ColumnPath> =
+    getColumnPaths(UnresolvedColumnsPolicy.Fail, selector)
+
+public fun <T, C> DataFrame<T>.getColumnWithPath(selector: ColumnSelector<T, C>): ColumnWithPath<C> =
+    getColumnsWithPaths(selector).single()
+
+public fun <T, C> DataFrame<T>.getColumns(selector: ColumnsSelector<T, C>): List<DataColumn<C>> = get(selector)
+
+public fun <T> DataFrame<T>.getColumns(vararg columns: String): List<AnyCol> = getColumns { columns.toColumnSet() }
+
+public fun <T> DataFrame<T>.getColumnIndex(col: AnyCol): Int = getColumnIndex(col.name())
+
+public fun <T> DataFrame<T>.getRows(range: IntRange): DataFrame<T> =
+    if (range == indices()) this else columns().map { col -> col[range] }.toDataFrame().cast()
+
+public fun <T> DataFrame<T>.getRows(indices: Iterable<Int>): DataFrame<T> =
+    columns().map { col -> col[indices] }.toDataFrame().cast()
+
+public fun <T> DataFrame<T>.getOrNull(index: Int): DataRow<T>? = if (index < 0 || index >= nrow) null else get(index)
+
+public fun <T> ColumnsContainer<T>.getFrameColumn(columnPath: ColumnPath): FrameColumn<*> =
+    get(columnPath).asAnyFrameColumn()
+
+public fun <T> ColumnsContainer<T>.getFrameColumn(columnName: String): FrameColumn<*> =
+    get(columnName).asAnyFrameColumn()
+
+public fun <T> ColumnsContainer<T>.getColumnGroup(columnPath: ColumnPath): ColumnGroup<*> =
+    get(columnPath).asColumnGroup()
+
+// region getColumn
+
+public fun <T> ColumnsContainer<T>.getColumn(name: String): AnyCol =
+    getColumnOrNull(name) ?: throw IllegalArgumentException("Column not found: '$name'")
+
+public fun <T, R> ColumnsContainer<T>.getColumn(column: ColumnReference<DataFrame<R>>): FrameColumn<R> =
+    getColumnOrNull(column)?.asFrameColumn() ?: throw IllegalArgumentException("FrameColumn not found: '$column'")
+
+public fun <T, R> ColumnsContainer<T>.getColumn(column: ColumnReference<DataRow<R>>): ColumnGroup<R> =
+    getColumnOrNull(column)?.asColumnGroup() ?: throw IllegalArgumentException("ColumnGroup not found: '$column'")
+
+public fun <T, R> ColumnsContainer<T>.getColumn(column: ColumnReference<R>): DataColumn<R> =
+    getColumnOrNull(column) ?: throw IllegalArgumentException("Column not found: '$column'")
+
+public fun <T> ColumnsContainer<T>.getColumn(path: ColumnPath): AnyCol =
+    getColumnOrNull(path) ?: throw IllegalArgumentException("Column not found: '$path'")
+
+public fun <T> ColumnsContainer<T>.getColumn(index: Int): AnyCol =
+    getColumnOrNull(index)
+        ?: throw IllegalArgumentException("Column index is out of bounds: $index. Columns count = $ncol")
+
+public fun <T, C> ColumnsContainer<T>.getColumn(selector: ColumnSelector<T, C>): DataColumn<C> = get(selector)
+
+// endregion
+
+// region getColumnGroup
+
+public fun <T> ColumnsContainer<T>.getColumnGroup(index: Int): ColumnGroup<*> = getColumn(index).asColumnGroup()
+
+public fun <T> ColumnsContainer<T>.getColumnGroup(name: String): ColumnGroup<*> = getColumn(name).asColumnGroup()
+
+public fun <T> ColumnsContainer<T>.getColumnGroup(column: KProperty<*>): ColumnGroup<*> =
+    getColumnGroup(column.columnName)
+
+public fun <T, C> ColumnsContainer<T>.getColumnGroup(column: ColumnReference<DataRow<C>>): ColumnGroup<C> =
+    getColumn(column)
+
+public fun <T, C> ColumnsContainer<T>.getColumnGroup(column: ColumnSelector<T, DataRow<C>>): ColumnGroup<C> =
+    get(column).asColumnGroup()
+
+// endregion
+
+// region getColumnGroupOrNull
+
+public fun <T> ColumnsContainer<T>.getColumnGroupOrNull(name: String): ColumnGroup<*>? =
+    getColumnOrNull(name)?.asColumnGroup()
+
+public fun <T> ColumnsContainer<T>.getColumnGroupOrNull(column: KProperty<*>): ColumnGroup<*>? =
+    getColumnGroupOrNull(column.columnName)
+
+// endregion
+
+// region containsColumn
+
+public fun <C> ColumnsContainer<*>.containsColumn(column: ColumnReference<C>): Boolean = getColumnOrNull(column) != null
+
+public fun ColumnsContainer<*>.containsColumn(column: KProperty<*>): Boolean = containsColumn(column.columnName)
+
+public operator fun ColumnsContainer<*>.contains(column: AnyColumnReference): Boolean = containsColumn(column)
+
+public operator fun ColumnsContainer<*>.contains(column: KProperty<*>): Boolean = containsColumn(column)
+
+// region rows
+
+public fun <T> DataFrame<T>.rows(): Iterable<DataRow<T>> =
+    object : Iterable<DataRow<T>> {
+        override fun iterator() =
+            object : Iterator<DataRow<T>> {
+                var nextRow = 0
+
+                override fun hasNext(): Boolean = nextRow < nrow
+
+                override fun next(): DataRow<T> {
+                    require(nextRow < nrow)
+                    return get(nextRow++)
+                }
+            }
+    }
+
+public fun <T> DataFrame<T>.rowsReversed(): Iterable<DataRow<T>> =
+    object : Iterable<DataRow<T>> {
+        override fun iterator() =
+            object : Iterator<DataRow<T>> {
+                var nextRow = nrow - 1
+
+                override fun hasNext(): Boolean = nextRow >= 0
+
+                override fun next(): DataRow<T> {
+                    require(nextRow >= 0)
+                    return get(nextRow--)
+                }
+            }
+    }
+
+// endregion
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/DataRowApi.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/DataRowApi.kt
new file mode 100644
index 000000000..568abfe0b
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/DataRowApi.kt
@@ -0,0 +1,216 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import org.jetbrains.kotlinx.dataframe.AnyColumnReference
+import org.jetbrains.kotlinx.dataframe.AnyRow
+import org.jetbrains.kotlinx.dataframe.ColumnsContainer
+import org.jetbrains.kotlinx.dataframe.DataColumn
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.DataRow
+import org.jetbrains.kotlinx.dataframe.RowExpression
+import org.jetbrains.kotlinx.dataframe.annotations.DataSchema
+import org.jetbrains.kotlinx.dataframe.columns.ColumnReference
+import org.jetbrains.kotlinx.dataframe.impl.columnName
+import org.jetbrains.kotlinx.dataframe.impl.owner
+import org.jetbrains.kotlinx.dataframe.index
+import org.jetbrains.kotlinx.dataframe.indices
+import org.jetbrains.kotlinx.dataframe.ncol
+import org.jetbrains.kotlinx.dataframe.nrow
+import kotlin.experimental.ExperimentalTypeInference
+import kotlin.reflect.KProperty
+import kotlin.reflect.KType
+
+public fun AnyRow.isEmpty(): Boolean = owner.columns().all { it[index] == null }
+
+public fun AnyRow.isNotEmpty(): Boolean = !isEmpty()
+
+public inline fun <reified R> AnyRow.valuesOf(): List<R> = values().filterIsInstance<R>()
+
+// region DataSchema
+@DataSchema
+public data class NameValuePair<V>(val name: String, val value: V)
+
+// Without these overloads row.transpose().name or row.map { name } won't resolve
+public val ColumnsContainer<NameValuePair<*>>.name: DataColumn<String>
+    @JvmName("NameValuePairAny_name")
+    get() = this["name"] as DataColumn<String>
+
+public val DataRow<NameValuePair<*>>.name: String
+    @JvmName("NameValuePairAny_name")
+    get() = this["name"] as String
+
+public val ColumnsContainer<NameValuePair<*>>.value: DataColumn<*>
+    @JvmName("NameValuePairAny_value")
+    get() = this["value"]
+
+public val DataRow<NameValuePair<*>>.value: Any?
+    @JvmName("NameValuePairAny_value")
+    get() = this["value"]
+
+// endregion
+
+public inline fun <reified R> AnyRow.namedValuesOf(): List<NameValuePair<R>> =
+    values().zip(columnNames()).filter { it.first is R }.map { NameValuePair(it.second, it.first as R) }
+
+public fun AnyRow.namedValues(): List<NameValuePair<Any?>> =
+    values().zip(columnNames()) { value, name -> NameValuePair(name, value) }
+
+// region getValue
+
+public fun <T> AnyRow.getValue(columnName: String): T = get(columnName) as T
+
+public fun <T> AnyRow.getValue(column: ColumnReference<T>): T = get(column)
+
+public fun <T> AnyRow.getValue(column: KProperty<T>): T = get(column)
+
+public fun <T> AnyRow.getValueOrNull(columnName: String): T? = getOrNull(columnName) as T?
+
+public fun <T> AnyRow.getValueOrNull(column: KProperty<T>): T? = getValueOrNull<T>(column.columnName)
+
+// endregion
+
+// region contains
+
+public fun AnyRow.containsKey(columnName: String): Boolean = owner.containsColumn(columnName)
+
+public fun AnyRow.containsKey(column: AnyColumnReference): Boolean = owner.containsColumn(column)
+
+public fun AnyRow.containsKey(column: KProperty<*>): Boolean = owner.containsColumn(column)
+
+public operator fun AnyRow.contains(column: AnyColumnReference): Boolean = containsKey(column)
+
+public operator fun AnyRow.contains(column: KProperty<*>): Boolean = containsKey(column)
+
+// endregion
+
+/**
+ * Calculates the difference between the results of a row expression computed on the current and previous DataRow.
+ *
+ * @return [firstRowValue] for the first row; difference between expression computed for current and previous row for the following rows
+ */
+internal interface DiffDocs
+
+/**
+ * Calculates the difference between the results of a row expression computed on the current and previous DataRow.
+ *
+ * @return null for the first row; difference between expression computed for current and previous row for the following rows
+ */
+internal interface DiffOrNullDocs
+
+/**
+ * Calculates the difference between the results of a row expression computed on the current and previous DataRow.
+ *
+ * @return [firstRowValue] for the first row; difference between expression computed for current and previous row for the following rows
+ */
+@OptIn(ExperimentalTypeInference::class)
+@OverloadResolutionByLambdaReturnType
+public fun <T> DataRow<T>.diff(firstRowResult: Double, expression: RowExpression<T, Double>): Double =
+    prev()?.let { p -> expression(this, this) - expression(p, p) }
+        ?: firstRowResult
+
+/**
+ * Calculates the difference between the results of a row expression computed on the current and previous DataRow.
+ *
+ * @return [firstRowValue] for the first row; difference between expression computed for current and previous row for the following rows
+ */
+@OptIn(ExperimentalTypeInference::class)
+@OverloadResolutionByLambdaReturnType
+// required to resolve `diff(0) { intValue }`
+public fun <T> DataRow<T>.diff(firstRowResult: Int, expression: RowExpression<T, Int>): Int =
+    prev()?.let { p -> expression(this, this) - expression(p, p) }
+        ?: firstRowResult
+
+/**
+ * Calculates the difference between the results of a row expression computed on the current and previous DataRow.
+ *
+ * @return [firstRowValue] for the first row; difference between expression computed for current and previous row for the following rows
+ */
+public fun <T> DataRow<T>.diff(firstRowResult: Long, expression: RowExpression<T, Long>): Long =
+    prev()?.let { p -> expression(this, this) - expression(p, p) }
+        ?: firstRowResult
+
+/**
+ * Calculates the difference between the results of a row expression computed on the current and previous DataRow.
+ *
+ * @return [firstRowValue] for the first row; difference between expression computed for current and previous row for the following rows
+ */
+public fun <T> DataRow<T>.diff(firstRowResult: Float, expression: RowExpression<T, Float>): Float =
+    prev()?.let { p -> expression(this, this) - expression(p, p) }
+        ?: firstRowResult
+
+/**
+ * Calculates the difference between the results of a row expression computed on the current and previous DataRow.
+ *
+ * @return null for the first row; difference between expression computed for current and previous row for the following rows
+ */
+@OptIn(ExperimentalTypeInference::class)
+@OverloadResolutionByLambdaReturnType
+public fun <T> DataRow<T>.diffOrNull(expression: RowExpression<T, Double>): Double? =
+    prev()?.let { p -> expression(this, this) - expression(p, p) }
+
+/**
+ * Calculates the difference between the results of a row expression computed on the current and previous DataRow.
+ *
+ * @return null for the first row; difference between expression computed for current and previous row for the following rows
+ */
+public fun <T> DataRow<T>.diffOrNull(expression: RowExpression<T, Int>): Int? =
+    prev()?.let { p -> expression(this, this) - expression(p, p) }
+
+/**
+ * Calculates the difference between the results of a row expression computed on the current and previous DataRow.
+ *
+ * @return null for the first row; difference between expression computed for current and previous row for the following rows
+ */
+public fun <T> DataRow<T>.diffOrNull(expression: RowExpression<T, Long>): Long? =
+    prev()?.let { p -> expression(this, this) - expression(p, p) }
+
+/**
+ * Calculates the difference between the results of a row expression computed on the current and previous DataRow.
+ *
+ * @return null for the first row; difference between expression computed for current and previous row for the following rows
+ */
+public fun <T> DataRow<T>.diffOrNull(expression: RowExpression<T, Float>): Float? =
+    prev()?.let { p -> expression(this, this) - expression(p, p) }
+
+public fun AnyRow.columnsCount(): Int = df().ncol
+
+public fun AnyRow.columnNames(): List<String> = df().columnNames()
+
+public fun AnyRow.columnTypes(): List<KType> = df().columnTypes()
+
+public fun <T> DataRow<T>.getRow(index: Int): DataRow<T> = getRowOrNull(index)!!
+
+public fun <T> DataRow<T>.getRows(indices: Iterable<Int>): DataFrame<T> = df().getRows(indices)
+
+public fun <T> DataRow<T>.getRows(indices: IntRange): DataFrame<T> = df().getRows(indices)
+
+public fun <T> DataRow<T>.getRowOrNull(index: Int): DataRow<T>? {
+    val df = df()
+    return if (index >= 0 && index < df.nrow) df[index] else null
+}
+
+public fun <T> DataRow<T>.prev(): DataRow<T>? {
+    val index = index()
+    return if (index > 0) df()[index - 1] else null
+}
+
+public fun <T> DataRow<T>.next(): DataRow<T>? {
+    val index = index()
+    val df = df()
+    return if (index < df.nrow - 1) df[index + 1] else null
+}
+
+public fun <T> DataRow<T>.relative(relativeIndices: Iterable<Int>): DataFrame<T> =
+    getRows(relativeIndices.mapNotNull { (index + it).let { if (it >= 0 && it < df().rowsCount()) it else null } })
+
+public fun <T> DataRow<T>.relative(relativeIndices: IntRange): DataFrame<T> =
+    getRows(
+        (relativeIndices.first + index).coerceIn(df().indices)..(relativeIndices.last + index).coerceIn(df().indices),
+    )
+
+public fun <T> DataRow<T>.movingAverage(k: Int, expression: RowExpression<T, Number>): Double {
+    var count = 0
+    return backwardIterable().take(k).sumOf {
+        count++
+        expression(it).toDouble()
+    } / count
+}
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/DataRowSchemaApi.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/DataRowSchemaApi.kt
new file mode 100644
index 000000000..774ac357b
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/DataRowSchemaApi.kt
@@ -0,0 +1,11 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import org.jetbrains.kotlinx.dataframe.DataFrame
+
+public interface DataRowSchema
+
+public inline fun <reified T : DataRowSchema> dataFrameOf(vararg rows: T): DataFrame<T> =
+    rows.asIterable().toDataFrame()
+
+public inline fun <reified T : DataRowSchema> DataFrame<T>.append(vararg rows: T): DataFrame<T> =
+    concat(dataFrameOf(*rows))
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/Defaults.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/Defaults.kt
new file mode 100644
index 000000000..646954aa4
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/Defaults.kt
@@ -0,0 +1,7 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+@PublishedApi
+internal val skipNA_default: Boolean = false
+
+@PublishedApi
+internal val ddof_default: Int = 1
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/JsonPath.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/JsonPath.kt
new file mode 100644
index 000000000..0150eb2bc
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/JsonPath.kt
@@ -0,0 +1,68 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import org.intellij.lang.annotations.Language
+import java.io.Serializable
+
+/**
+ * Simplistic JSON path implementation.
+ * Supports just keys (in bracket notation), double quotes, arrays, and wildcards.
+ *
+ * Examples:
+ * `$["store"]["book"][*]["author"]`
+ *
+ * `$[1]` will match `$[*]`
+ */
+@JvmInline
+public value class JsonPath(
+    @Language("jsonpath") public val path: String = "$",
+) : Serializable {
+
+    public fun append(name: String): JsonPath = JsonPath("$path[\"$name\"]")
+
+    public fun appendWildcard(): JsonPath = JsonPath("$path[*]")
+
+    public fun appendArrayWithIndex(index: Int): JsonPath = JsonPath("$path[$index]")
+
+    public fun appendArrayWithWildcard(): JsonPath = JsonPath("$path[*]")
+
+    public fun replaceLastWildcardWithIndex(index: Int): JsonPath =
+        JsonPath(
+            path.toCharArray().let { chars ->
+                val lastStarIndex = chars.lastIndexOf('*')
+                chars.flatMapIndexed { i, c ->
+                    if (i == lastStarIndex) {
+                        index.toString().toCharArray().toList()
+                    } else {
+                        listOf(c)
+                    }
+                }.joinToString("")
+            },
+        )
+
+    public fun prepend(name: String): JsonPath = JsonPath("\$[\"$name\"]" + path.removePrefix("$"))
+
+    public fun prependWildcard(): JsonPath = JsonPath("\$[*]" + path.removePrefix("$"))
+
+    public fun prependArrayWithIndex(index: Int): JsonPath = JsonPath("\$[$index]" + path.removePrefix("$"))
+
+    public fun prependArrayWithWildcard(): JsonPath = JsonPath("\$[*]" + path.removePrefix("$"))
+
+    public fun erasedIndices(): JsonPath = JsonPath(path.replace("""\[[0-9]+]""".toRegex(), "[*]"))
+
+    private fun splitPath() = path.split("[", "]").filter { it.isNotBlank() }
+
+    public fun matches(other: JsonPath): Boolean =
+        path == other.path ||
+            run {
+                val path = splitPath()
+                val otherPath = other.splitPath()
+
+                if (path.size != otherPath.size) {
+                    false
+                } else {
+                    path.zip(otherPath).all { (p, o) ->
+                        p == o || p == "*" || o == "*"
+                    }
+                }
+            }
+}
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/KeyValueProperty.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/KeyValueProperty.kt
new file mode 100644
index 000000000..56a52c2f3
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/KeyValueProperty.kt
@@ -0,0 +1,15 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import org.jetbrains.kotlinx.dataframe.annotations.ColumnName
+import org.jetbrains.kotlinx.dataframe.annotations.DataSchema
+
+/** A [DataSchema] interface / class can implement this if it represents a map-like data schema (so key: value). */
+@DataSchema
+public interface KeyValueProperty<T> {
+    // needs to be explicitly overridden in @DataSchema interface, otherwise extension functions won't generate (TODO)
+    public val key: String
+
+    // needs to be explicitly overridden in @DataSchema interface, otherwise type will be read as `T` and extensions won't generate (TODO)
+    @ColumnName("value")
+    public val `value`: T
+}
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/Nulls.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/Nulls.kt
new file mode 100644
index 000000000..10efb54a9
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/Nulls.kt
@@ -0,0 +1,1387 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import org.jetbrains.kotlinx.dataframe.AnyCol
+import org.jetbrains.kotlinx.dataframe.AnyColumnReference
+import org.jetbrains.kotlinx.dataframe.AnyFrame
+import org.jetbrains.kotlinx.dataframe.AnyRow
+import org.jetbrains.kotlinx.dataframe.ColumnsSelector
+import org.jetbrains.kotlinx.dataframe.DataColumn
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.annotations.Interpretable
+import org.jetbrains.kotlinx.dataframe.annotations.Refine
+import org.jetbrains.kotlinx.dataframe.api.DropNA.DropNASelectingOptions
+import org.jetbrains.kotlinx.dataframe.api.DropNaNs.DropNaNsSelectingOptions
+import org.jetbrains.kotlinx.dataframe.api.DropNulls.DropNullsSelectingOptions
+import org.jetbrains.kotlinx.dataframe.columns.ColumnKind
+import org.jetbrains.kotlinx.dataframe.columns.ColumnReference
+import org.jetbrains.kotlinx.dataframe.columns.toColumnSet
+import org.jetbrains.kotlinx.dataframe.documentation.NA
+import org.jetbrains.kotlinx.dataframe.documentation.NaN
+import org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns
+import org.jetbrains.kotlinx.dataframe.get
+import org.jetbrains.kotlinx.dataframe.typeClass
+import kotlin.reflect.KProperty
+
+// region fillNulls
+
+/**
+ * ## The Fill Nulls Operation
+ *
+ * Replaces `null` values with given value or expression.
+ * Specific case of [update].
+ *
+ * ### Check out: [Grammar][FillNulls.Grammar]
+ *
+ * For more information: [See `fillNulls` on the documentation website.](https://kotlin.github.io/dataframe/fill.html#fillnulls)
+ */
+internal interface FillNulls {
+
+    /** ## [**fillNulls**][fillNulls] Operation Grammar
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * [(What is this notation?)][org.jetbrains.kotlinx.dataframe.documentation.DslGrammar]
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     * [**fillNulls**][fillNulls]**`  {  `**[`columns`][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns]**` }`**
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     * `[ `__`.`__[**`where`**][org.jetbrains.kotlinx.dataframe.api.Update.where]**`  {  `**[`rowValueCondition`][org.jetbrains.kotlinx.dataframe.documentation.SelectingRows.RowValueCondition.WithExample]**`  }  `**`]`
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     * `[ `__`.`__[**`at`**][org.jetbrains.kotlinx.dataframe.api.Update.at]**`(`**[`rowIndices`][org.jetbrains.kotlinx.dataframe.api.CommonUpdateAtFunctionDoc.RowIndicesParam]**`)`**` ]`
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     * __`.`__[**`with`**][org.jetbrains.kotlinx.dataframe.api.Update.with]**`  {  `**[`rowExpression`][org.jetbrains.kotlinx.dataframe.documentation.ExpressionsGivenRow.RowValueExpression.WithExample]**` }`**
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     * `| `__`.`__[**`notNull`**][org.jetbrains.kotlinx.dataframe.api.Update.notNull]**`  {  `**[`rowExpression`][org.jetbrains.kotlinx.dataframe.documentation.ExpressionsGivenRow.RowValueExpression.WithExample]**` }`**
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     * `| `__`.`__[**`perCol`**][org.jetbrains.kotlinx.dataframe.api.Update.perCol]**`  {  `**[`colExpression`][org.jetbrains.kotlinx.dataframe.documentation.ExpressionsGivenColumn.ColumnExpression.WithExample]**` }`**
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     * `| `__`.`__[**`perRowCol`**][org.jetbrains.kotlinx.dataframe.api.Update.perRowCol]**`  {  `**[`rowColExpression`][org.jetbrains.kotlinx.dataframe.documentation.ExpressionsGivenRowAndColumn.RowColumnExpression.WithExample]**` }`**
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     * `| `__`.`__[**`withNull`**][org.jetbrains.kotlinx.dataframe.api.Update.withNull]**`()`**
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     * `| `__`.`__[**`withZero`**][org.jetbrains.kotlinx.dataframe.api.Update.withZero]**`()`**
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     * `| `__`.`__[**`asFrame`**][org.jetbrains.kotlinx.dataframe.api.Update.asFrame]**`  {  `**[`dataFrameExpression`][org.jetbrains.kotlinx.dataframe.documentation.ExpressionsGivenDataFrame.DataFrameExpression.WithExample]**` }`**
+     *
+     */
+    interface Grammar
+
+    /**
+     *
+     * ## Selecting Columns
+     * Selecting columns for various operations (including but not limited to
+     * [DataFrame.select][org.jetbrains.kotlinx.dataframe.DataFrame.select], [DataFrame.update][org.jetbrains.kotlinx.dataframe.DataFrame.update], [DataFrame.gather][org.jetbrains.kotlinx.dataframe.DataFrame.gather], and [DataFrame.fillNulls][org.jetbrains.kotlinx.dataframe.DataFrame.fillNulls])
+     * can be done in the following ways:
+     * ### 1. [Columns Selection DSL][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns.Dsl.WithExample]
+     * Select or express columns using the [Columns Selection DSL][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl].
+     * (Any (combination of) [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+     *
+     * This DSL is initiated by a [Columns Selector][org.jetbrains.kotlinx.dataframe.ColumnsSelector] lambda,
+     * which operates in the context of the [Columns Selection DSL][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl] and
+     * expects you to return a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn] or [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] (so, a [ColumnsResolver][org.jetbrains.kotlinx.dataframe.columns.ColumnsResolver]).
+     * This is an entity formed by calling any (combination) of the functions
+     * in the DSL that is or can be resolved into one or more columns.
+     *
+     * #### NOTE:
+     * While you can use the [String API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi.StringApi] and [KProperties API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi.KPropertiesApi]
+     * in this DSL directly with any function, they are NOT valid return types for the
+     * [Columns Selector][org.jetbrains.kotlinx.dataframe.ColumnsSelector] lambda. You'd need to turn them into a [ColumnReference][org.jetbrains.kotlinx.dataframe.columns.ColumnReference] first, for instance
+     * with a function like [`col("name")`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.col].
+     *
+     * ### Check out: [Columns Selection DSL Grammar][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.DslGrammar]
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * [See Column Selectors on the documentation website.](https://kotlin.github.io/dataframe/columnselectors.html)
+     *
+     * #### For example:
+     *
+     * `df.`[fillNulls][org.jetbrains.kotlinx.dataframe.api.fillNulls]` { length `[and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]` age }`
+     *
+     * `df.`[fillNulls][org.jetbrains.kotlinx.dataframe.api.fillNulls]`  {  `[cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`(1..5) }`
+     *
+     * `df.`[fillNulls][org.jetbrains.kotlinx.dataframe.api.fillNulls]`  {  `[colsOf][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[Double][Double]`>() }`
+     *
+     *
+     * #### NOTE: There's also a 'single column' variant used sometimes: [Column Selection DSL][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns.DslSingle.WithExample].
+     * ### 2. [Column names][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns.ColumnNames.WithExample]
+     * Select columns using their [column names][String]
+     * ([String API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi.StringApi]).
+     *
+     * #### For example:
+     *
+     * `df.`[fillNulls][org.jetbrains.kotlinx.dataframe.api.fillNulls]`("length", "age")`
+     *
+     * ### 3. [Column references][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns.ColumnAccessors.WithExample]
+     * Select columns using [column accessors][org.jetbrains.kotlinx.dataframe.columns.ColumnReference]
+     * ([Column Accessors API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi.ColumnAccessorsApi]).
+     *
+     * #### For example:
+     *
+     * `val length by `[column][org.jetbrains.kotlinx.dataframe.api.column]`<`[Double][Double]`>()`
+     *
+     * `val age by `[column][org.jetbrains.kotlinx.dataframe.api.column]`<`[Double][Double]`>()`
+     *
+     * `df.`[fillNulls][org.jetbrains.kotlinx.dataframe.api.fillNulls]`(length, age)`
+     *
+     * ### 4. [KProperties][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns.KProperties.WithExample]
+     * Select columns using [KProperties][KProperty] ([KProperties API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi.KPropertiesApi]).
+     *
+     * #### For example:
+     * ```kotlin
+     * data class Person(val length: Double, val age: Double)
+     * ```
+     *
+     * `df.`[fillNulls][org.jetbrains.kotlinx.dataframe.api.fillNulls]`(Person::length, Person::age)`
+     *
+     */
+    interface FillNullsSelectingOptions
+}
+
+private interface SetFillNullsOperationArg
+
+/**
+ * ## The Fill Nulls Operation
+ *
+ * Replaces `null` values with given value or expression.
+ * Specific case of [update][org.jetbrains.kotlinx.dataframe.api.update].
+ *
+ * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.FillNulls.Grammar]
+ *
+ * For more information: [See `fillNulls` on the documentation website.](https://kotlin.github.io/dataframe/fill.html#fillnulls)
+ *
+ * &nbsp;&nbsp;&nbsp;&nbsp;
+ *
+ * The columns to update need to be selected. See [Selecting Columns][org.jetbrains.kotlinx.dataframe.api.FillNulls.FillNullsSelectingOptions]
+ * for all the selecting options.
+ *
+ * ### This Fill Nulls Overload
+ *
+ * Select or express columns using the [Columns Selection DSL][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl].
+ * (Any (combination of) [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+ *
+ * This DSL is initiated by a [Columns Selector][org.jetbrains.kotlinx.dataframe.ColumnsSelector] lambda,
+ * which operates in the context of the [Columns Selection DSL][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl] and
+ * expects you to return a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn] or [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] (so, a [ColumnsResolver][org.jetbrains.kotlinx.dataframe.columns.ColumnsResolver]).
+ * This is an entity formed by calling any (combination) of the functions
+ * in the DSL that is or can be resolved into one or more columns.
+ *
+ * #### NOTE:
+ * While you can use the [String API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi.StringApi] and [KProperties API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi.KPropertiesApi]
+ * in this DSL directly with any function, they are NOT valid return types for the
+ * [Columns Selector][org.jetbrains.kotlinx.dataframe.ColumnsSelector] lambda. You'd need to turn them into a [ColumnReference][org.jetbrains.kotlinx.dataframe.columns.ColumnReference] first, for instance
+ * with a function like [`col("name")`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.col].
+ *
+ * ### Check out: [Columns Selection DSL Grammar][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.DslGrammar]
+ *
+ * &nbsp;&nbsp;&nbsp;&nbsp;
+ *
+ * [See Column Selectors on the documentation website.](https://kotlin.github.io/dataframe/columnselectors.html)
+ *
+ * #### For example:
+ *
+ * `df.`[fillNulls][org.jetbrains.kotlinx.dataframe.api.fillNulls]` { length `[and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]` age }`
+ *
+ * `df.`[fillNulls][org.jetbrains.kotlinx.dataframe.api.fillNulls]`  {  `[cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`(1..5) }`
+ *
+ * `df.`[fillNulls][org.jetbrains.kotlinx.dataframe.api.fillNulls]`  {  `[colsOf][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[Double][Double]`>() }`
+ *
+ *
+ * @param [columns] The [Columns Selector][org.jetbrains.kotlinx.dataframe.ColumnsSelector] used to select the columns of this [DataFrame][org.jetbrains.kotlinx.dataframe.DataFrame] to update.
+ */
+@Interpretable("FillNulls0")
+public fun <T, C> DataFrame<T>.fillNulls(columns: ColumnsSelector<T, C?>): Update<T, C?> =
+    update(columns).where { it == null }
+
+/**
+ * ## The Fill Nulls Operation
+ *
+ * Replaces `null` values with given value or expression.
+ * Specific case of [update][org.jetbrains.kotlinx.dataframe.api.update].
+ *
+ * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.FillNulls.Grammar]
+ *
+ * For more information: [See `fillNulls` on the documentation website.](https://kotlin.github.io/dataframe/fill.html#fillnulls)
+ *
+ * &nbsp;&nbsp;&nbsp;&nbsp;
+ *
+ * The columns to update need to be selected. See [Selecting Columns][org.jetbrains.kotlinx.dataframe.api.FillNulls.FillNullsSelectingOptions]
+ * for all the selecting options.
+ *
+ * ### This Fill Nulls Overload
+ *
+ * Select columns using their [column names][String]
+ * ([String API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi.StringApi]).
+ *
+ * #### For example:
+ *
+ * `df.`[fillNulls][org.jetbrains.kotlinx.dataframe.api.fillNulls]`("length", "age")`
+ *
+ * @param [columns] The [Strings][String] corresponding to the names of columns belonging to this [DataFrame][org.jetbrains.kotlinx.dataframe.DataFrame] to update.
+ */
+public fun <T> DataFrame<T>.fillNulls(vararg columns: String): Update<T, Any?> = fillNulls { columns.toColumnSet() }
+
+/**
+ * ## The Fill Nulls Operation
+ *
+ * Replaces `null` values with given value or expression.
+ * Specific case of [update][org.jetbrains.kotlinx.dataframe.api.update].
+ *
+ * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.FillNulls.Grammar]
+ *
+ * For more information: [See `fillNulls` on the documentation website.](https://kotlin.github.io/dataframe/fill.html#fillnulls)
+ *
+ * &nbsp;&nbsp;&nbsp;&nbsp;
+ *
+ * The columns to update need to be selected. See [Selecting Columns][org.jetbrains.kotlinx.dataframe.api.FillNulls.FillNullsSelectingOptions]
+ * for all the selecting options.
+ *
+ * ### This Fill Nulls Overload
+ *
+ * Select columns using [KProperties][KProperty] ([KProperties API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi.KPropertiesApi]).
+ *
+ * #### For example:
+ * ```kotlin
+ * data class Person(val length: Double, val age: Double)
+ * ```
+ *
+ * `df.`[fillNulls][org.jetbrains.kotlinx.dataframe.api.fillNulls]`(Person::length, Person::age)`
+ *
+ * @param [columns] The [KProperties][KProperty] corresponding to columns of this [DataFrame][org.jetbrains.kotlinx.dataframe.DataFrame] to update.
+ */
+public fun <T, C> DataFrame<T>.fillNulls(vararg columns: KProperty<C>): Update<T, C?> =
+    fillNulls { columns.toColumnSet() }
+
+/**
+ * ## The Fill Nulls Operation
+ *
+ * Replaces `null` values with given value or expression.
+ * Specific case of [update][org.jetbrains.kotlinx.dataframe.api.update].
+ *
+ * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.FillNulls.Grammar]
+ *
+ * For more information: [See `fillNulls` on the documentation website.](https://kotlin.github.io/dataframe/fill.html#fillnulls)
+ *
+ * &nbsp;&nbsp;&nbsp;&nbsp;
+ *
+ * The columns to update need to be selected. See [Selecting Columns][org.jetbrains.kotlinx.dataframe.api.FillNulls.FillNullsSelectingOptions]
+ * for all the selecting options.
+ *
+ * ### This Fill Nulls Overload
+ *
+ * Select columns using [column accessors][org.jetbrains.kotlinx.dataframe.columns.ColumnReference]
+ * ([Column Accessors API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi.ColumnAccessorsApi]).
+ *
+ * #### For example:
+ *
+ * `val length by `[column][org.jetbrains.kotlinx.dataframe.api.column]`<`[Double][Double]`>()`
+ *
+ * `val age by `[column][org.jetbrains.kotlinx.dataframe.api.column]`<`[Double][Double]`>()`
+ *
+ * `df.`[fillNulls][org.jetbrains.kotlinx.dataframe.api.fillNulls]`(length, age)`
+ *
+ * @param [columns] The [Column References][org.jetbrains.kotlinx.dataframe.columns.ColumnReference] of this [DataFrame][org.jetbrains.kotlinx.dataframe.DataFrame] to update.
+ */
+public fun <T, C> DataFrame<T>.fillNulls(vararg columns: ColumnReference<C>): Update<T, C?> =
+    fillNulls { columns.toColumnSet() }
+
+// endregion
+
+internal inline val Any?.isNaN: Boolean get() = (this is Double && isNaN()) || (this is Float && isNaN())
+
+internal inline val Any?.isNA: Boolean
+    get() = when (this) {
+        null -> true
+        is Double -> isNaN()
+        is Float -> isNaN()
+        is AnyRow -> allNA()
+        is AnyFrame -> isEmpty()
+        else -> false
+    }
+
+internal inline val AnyCol.canHaveNaN: Boolean get() = typeClass.let { it == Double::class || it == Float::class }
+
+internal inline val AnyCol.canHaveNA: Boolean get() = hasNulls() || canHaveNaN || kind() != ColumnKind.Value
+
+internal inline val Double?.isNA: Boolean get() = this == null || this.isNaN()
+
+internal inline val Float?.isNA: Boolean get() = this == null || this.isNaN()
+
+// region fillNaNs
+
+/**
+ * ## The Fill NaNs Operation
+ *
+ * Replaces [`NaN`][NaN] values with given value or expression.
+ * Specific case of [update].
+ *
+ * ### Check out: [Grammar][FillNaNs.Grammar]
+ *
+ * For more information: [See `fillNaNs` on the documentation website.](https://kotlin.github.io/dataframe/fill.html#fillnans)
+ */
+internal interface FillNaNs {
+
+    /** ## [fillNaNs][fillNaNs] Operation Grammar
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * [(What is this notation?)][org.jetbrains.kotlinx.dataframe.documentation.DslGrammar]
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     * [fillNaNs][fillNaNs]**`  {  `**[`columns`][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns]**` }`**
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     * `[ `__`.`__[**`where`**][org.jetbrains.kotlinx.dataframe.api.Update.where]**`  {  `**[`rowValueCondition`][org.jetbrains.kotlinx.dataframe.documentation.SelectingRows.RowValueCondition.WithExample]**`  }  `**`]`
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     * `[ `__`.`__[**`at`**][org.jetbrains.kotlinx.dataframe.api.Update.at]**`(`**[`rowIndices`][org.jetbrains.kotlinx.dataframe.api.CommonUpdateAtFunctionDoc.RowIndicesParam]**`)`**` ]`
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     * __`.`__[**`with`**][org.jetbrains.kotlinx.dataframe.api.Update.with]**`  {  `**[`rowExpression`][org.jetbrains.kotlinx.dataframe.documentation.ExpressionsGivenRow.RowValueExpression.WithExample]**` }`**
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     * `| `__`.`__[**`notNull`**][org.jetbrains.kotlinx.dataframe.api.Update.notNull]**`  {  `**[`rowExpression`][org.jetbrains.kotlinx.dataframe.documentation.ExpressionsGivenRow.RowValueExpression.WithExample]**` }`**
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     * `| `__`.`__[**`perCol`**][org.jetbrains.kotlinx.dataframe.api.Update.perCol]**`  {  `**[`colExpression`][org.jetbrains.kotlinx.dataframe.documentation.ExpressionsGivenColumn.ColumnExpression.WithExample]**` }`**
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     * `| `__`.`__[**`perRowCol`**][org.jetbrains.kotlinx.dataframe.api.Update.perRowCol]**`  {  `**[`rowColExpression`][org.jetbrains.kotlinx.dataframe.documentation.ExpressionsGivenRowAndColumn.RowColumnExpression.WithExample]**` }`**
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     * `| `__`.`__[**`withNull`**][org.jetbrains.kotlinx.dataframe.api.Update.withNull]**`()`**
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     * `| `__`.`__[**`withZero`**][org.jetbrains.kotlinx.dataframe.api.Update.withZero]**`()`**
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     * `| `__`.`__[**`asFrame`**][org.jetbrains.kotlinx.dataframe.api.Update.asFrame]**`  {  `**[`dataFrameExpression`][org.jetbrains.kotlinx.dataframe.documentation.ExpressionsGivenDataFrame.DataFrameExpression.WithExample]**` }`**
+     *
+     */
+    interface Grammar
+
+    /**
+     *
+     * ## Selecting Columns
+     * Selecting columns for various operations (including but not limited to
+     * [DataFrame.select][org.jetbrains.kotlinx.dataframe.DataFrame.select], [DataFrame.update][org.jetbrains.kotlinx.dataframe.DataFrame.update], [DataFrame.gather][org.jetbrains.kotlinx.dataframe.DataFrame.gather], and [DataFrame.fillNulls][org.jetbrains.kotlinx.dataframe.DataFrame.fillNulls])
+     * can be done in the following ways:
+     * ### 1. [Columns Selection DSL][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns.Dsl.WithExample]
+     * Select or express columns using the [Columns Selection DSL][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl].
+     * (Any (combination of) [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+     *
+     * This DSL is initiated by a [Columns Selector][org.jetbrains.kotlinx.dataframe.ColumnsSelector] lambda,
+     * which operates in the context of the [Columns Selection DSL][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl] and
+     * expects you to return a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn] or [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] (so, a [ColumnsResolver][org.jetbrains.kotlinx.dataframe.columns.ColumnsResolver]).
+     * This is an entity formed by calling any (combination) of the functions
+     * in the DSL that is or can be resolved into one or more columns.
+     *
+     * #### NOTE:
+     * While you can use the [String API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi.StringApi] and [KProperties API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi.KPropertiesApi]
+     * in this DSL directly with any function, they are NOT valid return types for the
+     * [Columns Selector][org.jetbrains.kotlinx.dataframe.ColumnsSelector] lambda. You'd need to turn them into a [ColumnReference][org.jetbrains.kotlinx.dataframe.columns.ColumnReference] first, for instance
+     * with a function like [`col("name")`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.col].
+     *
+     * ### Check out: [Columns Selection DSL Grammar][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.DslGrammar]
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * [See Column Selectors on the documentation website.](https://kotlin.github.io/dataframe/columnselectors.html)
+     *
+     * #### For example:
+     *
+     * `df.`[fillNaNs][org.jetbrains.kotlinx.dataframe.api.fillNaNs]` { length `[and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]` age }`
+     *
+     * `df.`[fillNaNs][org.jetbrains.kotlinx.dataframe.api.fillNaNs]`  {  `[cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`(1..5) }`
+     *
+     * `df.`[fillNaNs][org.jetbrains.kotlinx.dataframe.api.fillNaNs]`  {  `[colsOf][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[Double][Double]`>() }`
+     *
+     *
+     * #### NOTE: There's also a 'single column' variant used sometimes: [Column Selection DSL][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns.DslSingle.WithExample].
+     * ### 2. [Column names][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns.ColumnNames.WithExample]
+     * Select columns using their [column names][String]
+     * ([String API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi.StringApi]).
+     *
+     * #### For example:
+     *
+     * `df.`[fillNaNs][org.jetbrains.kotlinx.dataframe.api.fillNaNs]`("length", "age")`
+     *
+     * ### 3. [Column references][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns.ColumnAccessors.WithExample]
+     * Select columns using [column accessors][org.jetbrains.kotlinx.dataframe.columns.ColumnReference]
+     * ([Column Accessors API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi.ColumnAccessorsApi]).
+     *
+     * #### For example:
+     *
+     * `val length by `[column][org.jetbrains.kotlinx.dataframe.api.column]`<`[Double][Double]`>()`
+     *
+     * `val age by `[column][org.jetbrains.kotlinx.dataframe.api.column]`<`[Double][Double]`>()`
+     *
+     * `df.`[fillNaNs][org.jetbrains.kotlinx.dataframe.api.fillNaNs]`(length, age)`
+     *
+     * ### 4. [KProperties][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns.KProperties.WithExample]
+     * Select columns using [KProperties][KProperty] ([KProperties API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi.KPropertiesApi]).
+     *
+     * #### For example:
+     * ```kotlin
+     * data class Person(val length: Double, val age: Double)
+     * ```
+     *
+     * `df.`[fillNaNs][org.jetbrains.kotlinx.dataframe.api.fillNaNs]`(Person::length, Person::age)`
+     *
+     */
+    interface FillNaNsSelectingOptions
+}
+
+/**
+ * ## The Fill NaNs Operation
+ *
+ * Replaces [`NaN`][org.jetbrains.kotlinx.dataframe.documentation.NaN] values with given value or expression.
+ * Specific case of [update][org.jetbrains.kotlinx.dataframe.api.update].
+ *
+ * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.FillNaNs.Grammar]
+ *
+ * For more information: [See `fillNaNs` on the documentation website.](https://kotlin.github.io/dataframe/fill.html#fillnans)
+ *
+ * &nbsp;&nbsp;&nbsp;&nbsp;
+ *
+ * The columns to update need to be selected. See [Selecting Columns][org.jetbrains.kotlinx.dataframe.api.FillNaNs.FillNaNsSelectingOptions]
+ * for all the selecting options.
+ *
+ * ### This Fill NaNs Overload
+ * Select or express columns using the [Columns Selection DSL][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl].
+ * (Any (combination of) [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+ *
+ * This DSL is initiated by a [Columns Selector][org.jetbrains.kotlinx.dataframe.ColumnsSelector] lambda,
+ * which operates in the context of the [Columns Selection DSL][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl] and
+ * expects you to return a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn] or [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] (so, a [ColumnsResolver][org.jetbrains.kotlinx.dataframe.columns.ColumnsResolver]).
+ * This is an entity formed by calling any (combination) of the functions
+ * in the DSL that is or can be resolved into one or more columns.
+ *
+ * #### NOTE:
+ * While you can use the [String API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi.StringApi] and [KProperties API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi.KPropertiesApi]
+ * in this DSL directly with any function, they are NOT valid return types for the
+ * [Columns Selector][org.jetbrains.kotlinx.dataframe.ColumnsSelector] lambda. You'd need to turn them into a [ColumnReference][org.jetbrains.kotlinx.dataframe.columns.ColumnReference] first, for instance
+ * with a function like [`col("name")`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.col].
+ *
+ * ### Check out: [Columns Selection DSL Grammar][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.DslGrammar]
+ *
+ * &nbsp;&nbsp;&nbsp;&nbsp;
+ *
+ * [See Column Selectors on the documentation website.](https://kotlin.github.io/dataframe/columnselectors.html)
+ *
+ * #### For example:
+ *
+ * `df.`[fillNaNs][org.jetbrains.kotlinx.dataframe.api.fillNaNs]` { length `[and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]` age }`
+ *
+ * `df.`[fillNaNs][org.jetbrains.kotlinx.dataframe.api.fillNaNs]`  {  `[cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`(1..5) }`
+ *
+ * `df.`[fillNaNs][org.jetbrains.kotlinx.dataframe.api.fillNaNs]`  {  `[colsOf][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[Double][Double]`>() }`
+ *
+ *
+ * @param [columns] The [Columns Selector][org.jetbrains.kotlinx.dataframe.ColumnsSelector] used to select the columns of this [DataFrame][org.jetbrains.kotlinx.dataframe.DataFrame] to update.
+ */
+public fun <T, C> DataFrame<T>.fillNaNs(columns: ColumnsSelector<T, C>): Update<T, C> =
+    update(columns).where { it.isNaN }
+
+/**
+ * ## The Fill NaNs Operation
+ *
+ * Replaces [`NaN`][org.jetbrains.kotlinx.dataframe.documentation.NaN] values with given value or expression.
+ * Specific case of [update][org.jetbrains.kotlinx.dataframe.api.update].
+ *
+ * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.FillNaNs.Grammar]
+ *
+ * For more information: [See `fillNaNs` on the documentation website.](https://kotlin.github.io/dataframe/fill.html#fillnans)
+ *
+ * &nbsp;&nbsp;&nbsp;&nbsp;
+ *
+ * The columns to update need to be selected. See [Selecting Columns][org.jetbrains.kotlinx.dataframe.api.FillNaNs.FillNaNsSelectingOptions]
+ * for all the selecting options.
+ *
+ * ### This Fill NaNs Overload
+ * Select columns using their [column names][String]
+ * ([String API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi.StringApi]).
+ *
+ * #### For example:
+ *
+ * `df.`[fillNaNs][org.jetbrains.kotlinx.dataframe.api.fillNaNs]`("length", "age")`
+ *
+ * @param [columns] The [Strings][String] corresponding to the names of columns belonging to this [DataFrame][org.jetbrains.kotlinx.dataframe.DataFrame] to update.
+ */
+public fun <T> DataFrame<T>.fillNaNs(vararg columns: String): Update<T, Any?> = fillNaNs { columns.toColumnSet() }
+
+/**
+ * ## The Fill NaNs Operation
+ *
+ * Replaces [`NaN`][org.jetbrains.kotlinx.dataframe.documentation.NaN] values with given value or expression.
+ * Specific case of [update][org.jetbrains.kotlinx.dataframe.api.update].
+ *
+ * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.FillNaNs.Grammar]
+ *
+ * For more information: [See `fillNaNs` on the documentation website.](https://kotlin.github.io/dataframe/fill.html#fillnans)
+ *
+ * &nbsp;&nbsp;&nbsp;&nbsp;
+ *
+ * The columns to update need to be selected. See [Selecting Columns][org.jetbrains.kotlinx.dataframe.api.FillNaNs.FillNaNsSelectingOptions]
+ * for all the selecting options.
+ *
+ * ### This Fill NaNs Overload
+ * Select columns using [KProperties][KProperty] ([KProperties API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi.KPropertiesApi]).
+ *
+ * #### For example:
+ * ```kotlin
+ * data class Person(val length: Double, val age: Double)
+ * ```
+ *
+ * `df.`[fillNaNs][org.jetbrains.kotlinx.dataframe.api.fillNaNs]`(Person::length, Person::age)`
+ *
+ * @param [columns] The [KProperties][KProperty] corresponding to columns of this [DataFrame][org.jetbrains.kotlinx.dataframe.DataFrame] to update.
+ */
+public fun <T, C> DataFrame<T>.fillNaNs(vararg columns: KProperty<C>): Update<T, C> = fillNaNs { columns.toColumnSet() }
+
+/**
+ * ## The Fill NaNs Operation
+ *
+ * Replaces [`NaN`][org.jetbrains.kotlinx.dataframe.documentation.NaN] values with given value or expression.
+ * Specific case of [update][org.jetbrains.kotlinx.dataframe.api.update].
+ *
+ * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.FillNaNs.Grammar]
+ *
+ * For more information: [See `fillNaNs` on the documentation website.](https://kotlin.github.io/dataframe/fill.html#fillnans)
+ *
+ * &nbsp;&nbsp;&nbsp;&nbsp;
+ *
+ * The columns to update need to be selected. See [Selecting Columns][org.jetbrains.kotlinx.dataframe.api.FillNaNs.FillNaNsSelectingOptions]
+ * for all the selecting options.
+ *
+ * ### This Fill NaNs Overload
+ * Select columns using [column accessors][org.jetbrains.kotlinx.dataframe.columns.ColumnReference]
+ * ([Column Accessors API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi.ColumnAccessorsApi]).
+ *
+ * #### For example:
+ *
+ * `val length by `[column][org.jetbrains.kotlinx.dataframe.api.column]`<`[Double][Double]`>()`
+ *
+ * `val age by `[column][org.jetbrains.kotlinx.dataframe.api.column]`<`[Double][Double]`>()`
+ *
+ * `df.`[fillNaNs][org.jetbrains.kotlinx.dataframe.api.fillNaNs]`(length, age)`
+ *
+ * @param [columns] The [Column References][org.jetbrains.kotlinx.dataframe.columns.ColumnReference] of this [DataFrame][org.jetbrains.kotlinx.dataframe.DataFrame] to update.
+ */
+public fun <T, C> DataFrame<T>.fillNaNs(vararg columns: ColumnReference<C>): Update<T, C> =
+    fillNaNs { columns.toColumnSet() }
+
+// endregion
+
+// region fillNA
+
+/**
+ * ## The Fill NA Operation
+ *
+ * Replaces [`NA`][NA] values with given value or expression.
+ * Specific case of [update].
+ *
+ * ### Check out: [Grammar][FillNA.Grammar]
+ *
+ * For more information: [See `fillNA` on the documentation website.](https://kotlin.github.io/dataframe/fill.html#fillna)
+ */
+internal interface FillNA {
+
+    /** ## [fillNA][fillNA] Operation Grammar
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * [(What is this notation?)][org.jetbrains.kotlinx.dataframe.documentation.DslGrammar]
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     * [fillNA][fillNA]**`  {  `**[`columns`][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns]**` }`**
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     * `[ `__`.`__[**`where`**][org.jetbrains.kotlinx.dataframe.api.Update.where]**`  {  `**[`rowValueCondition`][org.jetbrains.kotlinx.dataframe.documentation.SelectingRows.RowValueCondition.WithExample]**`  }  `**`]`
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     * `[ `__`.`__[**`at`**][org.jetbrains.kotlinx.dataframe.api.Update.at]**`(`**[`rowIndices`][org.jetbrains.kotlinx.dataframe.api.CommonUpdateAtFunctionDoc.RowIndicesParam]**`)`**` ]`
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     * __`.`__[**`with`**][org.jetbrains.kotlinx.dataframe.api.Update.with]**`  {  `**[`rowExpression`][org.jetbrains.kotlinx.dataframe.documentation.ExpressionsGivenRow.RowValueExpression.WithExample]**` }`**
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     * `| `__`.`__[**`notNull`**][org.jetbrains.kotlinx.dataframe.api.Update.notNull]**`  {  `**[`rowExpression`][org.jetbrains.kotlinx.dataframe.documentation.ExpressionsGivenRow.RowValueExpression.WithExample]**` }`**
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     * `| `__`.`__[**`perCol`**][org.jetbrains.kotlinx.dataframe.api.Update.perCol]**`  {  `**[`colExpression`][org.jetbrains.kotlinx.dataframe.documentation.ExpressionsGivenColumn.ColumnExpression.WithExample]**` }`**
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     * `| `__`.`__[**`perRowCol`**][org.jetbrains.kotlinx.dataframe.api.Update.perRowCol]**`  {  `**[`rowColExpression`][org.jetbrains.kotlinx.dataframe.documentation.ExpressionsGivenRowAndColumn.RowColumnExpression.WithExample]**` }`**
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     * `| `__`.`__[**`withNull`**][org.jetbrains.kotlinx.dataframe.api.Update.withNull]**`()`**
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     * `| `__`.`__[**`withZero`**][org.jetbrains.kotlinx.dataframe.api.Update.withZero]**`()`**
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     * `| `__`.`__[**`asFrame`**][org.jetbrains.kotlinx.dataframe.api.Update.asFrame]**`  {  `**[`dataFrameExpression`][org.jetbrains.kotlinx.dataframe.documentation.ExpressionsGivenDataFrame.DataFrameExpression.WithExample]**` }`**
+     *
+     */
+    interface Grammar
+
+    /**
+     *
+     * ## Selecting Columns
+     * Selecting columns for various operations (including but not limited to
+     * [DataFrame.select][org.jetbrains.kotlinx.dataframe.DataFrame.select], [DataFrame.update][org.jetbrains.kotlinx.dataframe.DataFrame.update], [DataFrame.gather][org.jetbrains.kotlinx.dataframe.DataFrame.gather], and [DataFrame.fillNulls][org.jetbrains.kotlinx.dataframe.DataFrame.fillNulls])
+     * can be done in the following ways:
+     * ### 1. [Columns Selection DSL][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns.Dsl.WithExample]
+     * Select or express columns using the [Columns Selection DSL][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl].
+     * (Any (combination of) [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+     *
+     * This DSL is initiated by a [Columns Selector][org.jetbrains.kotlinx.dataframe.ColumnsSelector] lambda,
+     * which operates in the context of the [Columns Selection DSL][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl] and
+     * expects you to return a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn] or [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] (so, a [ColumnsResolver][org.jetbrains.kotlinx.dataframe.columns.ColumnsResolver]).
+     * This is an entity formed by calling any (combination) of the functions
+     * in the DSL that is or can be resolved into one or more columns.
+     *
+     * #### NOTE:
+     * While you can use the [String API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi.StringApi] and [KProperties API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi.KPropertiesApi]
+     * in this DSL directly with any function, they are NOT valid return types for the
+     * [Columns Selector][org.jetbrains.kotlinx.dataframe.ColumnsSelector] lambda. You'd need to turn them into a [ColumnReference][org.jetbrains.kotlinx.dataframe.columns.ColumnReference] first, for instance
+     * with a function like [`col("name")`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.col].
+     *
+     * ### Check out: [Columns Selection DSL Grammar][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.DslGrammar]
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * [See Column Selectors on the documentation website.](https://kotlin.github.io/dataframe/columnselectors.html)
+     *
+     * #### For example:
+     *
+     * `df.`[fillNA][org.jetbrains.kotlinx.dataframe.api.fillNA]` { length `[and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]` age }`
+     *
+     * `df.`[fillNA][org.jetbrains.kotlinx.dataframe.api.fillNA]`  {  `[cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`(1..5) }`
+     *
+     * `df.`[fillNA][org.jetbrains.kotlinx.dataframe.api.fillNA]`  {  `[colsOf][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[Double][Double]`>() }`
+     *
+     *
+     * #### NOTE: There's also a 'single column' variant used sometimes: [Column Selection DSL][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns.DslSingle.WithExample].
+     * ### 2. [Column names][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns.ColumnNames.WithExample]
+     * Select columns using their [column names][String]
+     * ([String API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi.StringApi]).
+     *
+     * #### For example:
+     *
+     * `df.`[fillNA][org.jetbrains.kotlinx.dataframe.api.fillNA]`("length", "age")`
+     *
+     * ### 3. [Column references][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns.ColumnAccessors.WithExample]
+     * Select columns using [column accessors][org.jetbrains.kotlinx.dataframe.columns.ColumnReference]
+     * ([Column Accessors API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi.ColumnAccessorsApi]).
+     *
+     * #### For example:
+     *
+     * `val length by `[column][org.jetbrains.kotlinx.dataframe.api.column]`<`[Double][Double]`>()`
+     *
+     * `val age by `[column][org.jetbrains.kotlinx.dataframe.api.column]`<`[Double][Double]`>()`
+     *
+     * `df.`[fillNA][org.jetbrains.kotlinx.dataframe.api.fillNA]`(length, age)`
+     *
+     * ### 4. [KProperties][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns.KProperties.WithExample]
+     * Select columns using [KProperties][KProperty] ([KProperties API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi.KPropertiesApi]).
+     *
+     * #### For example:
+     * ```kotlin
+     * data class Person(val length: Double, val age: Double)
+     * ```
+     *
+     * `df.`[fillNA][org.jetbrains.kotlinx.dataframe.api.fillNA]`(Person::length, Person::age)`
+     *
+     */
+    interface FillNASelectingOptions
+}
+
+/**
+ * ## The Fill NA Operation
+ *
+ * Replaces [`NA`][org.jetbrains.kotlinx.dataframe.documentation.NA] values with given value or expression.
+ * Specific case of [update][org.jetbrains.kotlinx.dataframe.api.update].
+ *
+ * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.FillNA.Grammar]
+ *
+ * For more information: [See `fillNA` on the documentation website.](https://kotlin.github.io/dataframe/fill.html#fillna)
+ *
+ * &nbsp;&nbsp;&nbsp;&nbsp;
+ *
+ * The columns to update need to be selected. See [Selecting Columns][org.jetbrains.kotlinx.dataframe.api.FillNA.FillNASelectingOptions]
+ * for all the selecting options.
+ *
+ * ### This Fill NA Overload
+ * Select or express columns using the [Columns Selection DSL][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl].
+ * (Any (combination of) [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+ *
+ * This DSL is initiated by a [Columns Selector][org.jetbrains.kotlinx.dataframe.ColumnsSelector] lambda,
+ * which operates in the context of the [Columns Selection DSL][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl] and
+ * expects you to return a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn] or [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] (so, a [ColumnsResolver][org.jetbrains.kotlinx.dataframe.columns.ColumnsResolver]).
+ * This is an entity formed by calling any (combination) of the functions
+ * in the DSL that is or can be resolved into one or more columns.
+ *
+ * #### NOTE:
+ * While you can use the [String API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi.StringApi] and [KProperties API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi.KPropertiesApi]
+ * in this DSL directly with any function, they are NOT valid return types for the
+ * [Columns Selector][org.jetbrains.kotlinx.dataframe.ColumnsSelector] lambda. You'd need to turn them into a [ColumnReference][org.jetbrains.kotlinx.dataframe.columns.ColumnReference] first, for instance
+ * with a function like [`col("name")`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.col].
+ *
+ * ### Check out: [Columns Selection DSL Grammar][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.DslGrammar]
+ *
+ * &nbsp;&nbsp;&nbsp;&nbsp;
+ *
+ * [See Column Selectors on the documentation website.](https://kotlin.github.io/dataframe/columnselectors.html)
+ *
+ * #### For example:
+ *
+ * `df.`[fillNA][org.jetbrains.kotlinx.dataframe.api.fillNA]` { length `[and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]` age }`
+ *
+ * `df.`[fillNA][org.jetbrains.kotlinx.dataframe.api.fillNA]`  {  `[cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`(1..5) }`
+ *
+ * `df.`[fillNA][org.jetbrains.kotlinx.dataframe.api.fillNA]`  {  `[colsOf][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[Double][Double]`>() }`
+ *
+ *
+ * @param [columns] The [Columns Selector][org.jetbrains.kotlinx.dataframe.ColumnsSelector] used to select the columns of this [DataFrame][org.jetbrains.kotlinx.dataframe.DataFrame] to update.
+ */
+public fun <T, C> DataFrame<T>.fillNA(columns: ColumnsSelector<T, C?>): Update<T, C?> =
+    update(columns).where { it.isNA }
+
+/**
+ * ## The Fill NA Operation
+ *
+ * Replaces [`NA`][org.jetbrains.kotlinx.dataframe.documentation.NA] values with given value or expression.
+ * Specific case of [update][org.jetbrains.kotlinx.dataframe.api.update].
+ *
+ * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.FillNA.Grammar]
+ *
+ * For more information: [See `fillNA` on the documentation website.](https://kotlin.github.io/dataframe/fill.html#fillna)
+ *
+ * &nbsp;&nbsp;&nbsp;&nbsp;
+ *
+ * The columns to update need to be selected. See [Selecting Columns][org.jetbrains.kotlinx.dataframe.api.FillNA.FillNASelectingOptions]
+ * for all the selecting options.
+ *
+ * ### This Fill NA Overload
+ * Select columns using their [column names][String]
+ * ([String API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi.StringApi]).
+ *
+ * #### For example:
+ *
+ * `df.`[fillNA][org.jetbrains.kotlinx.dataframe.api.fillNA]`("length", "age")`
+ *
+ * @param [columns] The [Strings][String] corresponding to the names of columns belonging to this [DataFrame][org.jetbrains.kotlinx.dataframe.DataFrame] to update.
+ */
+public fun <T> DataFrame<T>.fillNA(vararg columns: String): Update<T, Any?> = fillNA { columns.toColumnSet() }
+
+/**
+ * ## The Fill NA Operation
+ *
+ * Replaces [`NA`][org.jetbrains.kotlinx.dataframe.documentation.NA] values with given value or expression.
+ * Specific case of [update][org.jetbrains.kotlinx.dataframe.api.update].
+ *
+ * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.FillNA.Grammar]
+ *
+ * For more information: [See `fillNA` on the documentation website.](https://kotlin.github.io/dataframe/fill.html#fillna)
+ *
+ * &nbsp;&nbsp;&nbsp;&nbsp;
+ *
+ * The columns to update need to be selected. See [Selecting Columns][org.jetbrains.kotlinx.dataframe.api.FillNA.FillNASelectingOptions]
+ * for all the selecting options.
+ *
+ * ### This Fill NA Overload
+ * Select columns using [KProperties][KProperty] ([KProperties API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi.KPropertiesApi]).
+ *
+ * #### For example:
+ * ```kotlin
+ * data class Person(val length: Double, val age: Double)
+ * ```
+ *
+ * `df.`[fillNA][org.jetbrains.kotlinx.dataframe.api.fillNA]`(Person::length, Person::age)`
+ *
+ * @param [columns] The [KProperties][KProperty] corresponding to columns of this [DataFrame][org.jetbrains.kotlinx.dataframe.DataFrame] to update.
+ */
+public fun <T, C> DataFrame<T>.fillNA(vararg columns: KProperty<C>): Update<T, C?> = fillNA { columns.toColumnSet() }
+
+/**
+ * ## The Fill NA Operation
+ *
+ * Replaces [`NA`][org.jetbrains.kotlinx.dataframe.documentation.NA] values with given value or expression.
+ * Specific case of [update][org.jetbrains.kotlinx.dataframe.api.update].
+ *
+ * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.FillNA.Grammar]
+ *
+ * For more information: [See `fillNA` on the documentation website.](https://kotlin.github.io/dataframe/fill.html#fillna)
+ *
+ * &nbsp;&nbsp;&nbsp;&nbsp;
+ *
+ * The columns to update need to be selected. See [Selecting Columns][org.jetbrains.kotlinx.dataframe.api.FillNA.FillNASelectingOptions]
+ * for all the selecting options.
+ *
+ * ### This Fill NA Overload
+ * Select columns using [column accessors][org.jetbrains.kotlinx.dataframe.columns.ColumnReference]
+ * ([Column Accessors API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi.ColumnAccessorsApi]).
+ *
+ * #### For example:
+ *
+ * `val length by `[column][org.jetbrains.kotlinx.dataframe.api.column]`<`[Double][Double]`>()`
+ *
+ * `val age by `[column][org.jetbrains.kotlinx.dataframe.api.column]`<`[Double][Double]`>()`
+ *
+ * `df.`[fillNA][org.jetbrains.kotlinx.dataframe.api.fillNA]`(length, age)`
+ *
+ * @param [columns] The [Column References][org.jetbrains.kotlinx.dataframe.columns.ColumnReference] of this [DataFrame][org.jetbrains.kotlinx.dataframe.DataFrame] to update.
+ */
+public fun <T, C> DataFrame<T>.fillNA(vararg columns: ColumnReference<C>): Update<T, C?> =
+    fillNA { columns.toColumnSet() }
+
+// endregion
+
+// region dropNulls
+
+/**
+ * ## The Drop Nulls Operation
+ *
+ * Removes rows with `null` values. Specific case of [drop][org.jetbrains.kotlinx.dataframe.DataFrame.drop].
+ *
+ * Optionally, you can select which columns to operate on (see [Selecting Columns][org.jetbrains.kotlinx.dataframe.api.DropNulls.DropNullsSelectingOptions]).
+ *
+ * Also, you can supply `whereAllNull = true` to only drop rows where all selected cells are `null`. By default,
+ * rows are dropped if any of the selected cells are `null`.
+ *
+ * For more information: [See `dropNulls` on the documentation website.](https://kotlin.github.io/dataframe/drop.html#dropnulls)
+ * ### This Drop Nulls Overload
+ * Select or express columns using the [Columns Selection DSL][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl].
+ * (Any (combination of) [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+ *
+ * This DSL is initiated by a [Columns Selector][org.jetbrains.kotlinx.dataframe.ColumnsSelector] lambda,
+ * which operates in the context of the [Columns Selection DSL][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl] and
+ * expects you to return a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn] or [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] (so, a [ColumnsResolver][org.jetbrains.kotlinx.dataframe.columns.ColumnsResolver]).
+ * This is an entity formed by calling any (combination) of the functions
+ * in the DSL that is or can be resolved into one or more columns.
+ *
+ * #### NOTE:
+ * While you can use the [String API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi.StringApi] and [KProperties API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi.KPropertiesApi]
+ * in this DSL directly with any function, they are NOT valid return types for the
+ * [Columns Selector][org.jetbrains.kotlinx.dataframe.ColumnsSelector] lambda. You'd need to turn them into a [ColumnReference][org.jetbrains.kotlinx.dataframe.columns.ColumnReference] first, for instance
+ * with a function like [`col("name")`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.col].
+ *
+ * ### Check out: [Columns Selection DSL Grammar][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.DslGrammar]
+ *
+ * &nbsp;&nbsp;&nbsp;&nbsp;
+ *
+ * [See Column Selectors on the documentation website.](https://kotlin.github.io/dataframe/columnselectors.html)
+ *
+ * #### For example:
+ *
+ * `df.`[dropNulls][org.jetbrains.kotlinx.dataframe.api.dropNulls]` { length `[and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]` age }`
+ *
+ * `df.`[dropNulls][org.jetbrains.kotlinx.dataframe.api.dropNulls]`  {  `[cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`(1..5) }`
+ *
+ * `df.`[dropNulls][org.jetbrains.kotlinx.dataframe.api.dropNulls]`  {  `[colsOf][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[Double][Double]`>() }`
+ *
+ *
+ * `df.`[dropNulls][dropNulls]`(whereAllNull = true) { `[colsOf][colsOf]`<`[Double][Double]`>() }`
+ * @param whereAllNull `false` by default.
+ *   If `true`, rows are dropped if all selected cells are `null`.
+ *   If `false`, rows are dropped if any of the selected cells is `null`.
+ * @param columns The [Columns Selector][org.jetbrains.kotlinx.dataframe.ColumnsSelector] used to select the columns of this [DataFrame][org.jetbrains.kotlinx.dataframe.DataFrame] to drop rows in.
+ */
+@Refine
+@Interpretable("DropNulls0")
+public fun <T> DataFrame<T>.dropNulls(whereAllNull: Boolean = false, columns: ColumnsSelector<T, *>): DataFrame<T> {
+    val cols = this[columns]
+    return if (whereAllNull) {
+        drop { row -> cols.all { col -> col[row] == null } }
+    } else {
+        drop { row -> cols.any { col -> col[row] == null } }
+    }
+}
+
+/**
+ * ## The Drop Nulls Operation
+ *
+ * Removes rows with `null` values. Specific case of [drop][org.jetbrains.kotlinx.dataframe.DataFrame.drop].
+ *
+ * Optionally, you can select which columns to operate on (see [Selecting Columns][org.jetbrains.kotlinx.dataframe.api.DropNulls.DropNullsSelectingOptions]).
+ *
+ * Also, you can supply `whereAllNull = true` to only drop rows where all selected cells are `null`. By default,
+ * rows are dropped if any of the selected cells are `null`.
+ *
+ * For more information: [See `dropNulls` on the documentation website.](https://kotlin.github.io/dataframe/drop.html#dropnulls)
+ * ### This Drop Nulls Overload
+ * This overload operates on all columns in the [DataFrame].
+ * @param whereAllNull `false` by default.
+ *   If `true`, rows are dropped if all selected cells are `null`.
+ *   If `false`, rows are dropped if any of the selected cells is `null`.
+ */
+public fun <T> DataFrame<T>.dropNulls(whereAllNull: Boolean = false): DataFrame<T> = dropNulls(whereAllNull) { all() }
+
+/**
+ * ## The Drop Nulls Operation
+ *
+ * Removes rows with `null` values. Specific case of [drop][org.jetbrains.kotlinx.dataframe.DataFrame.drop].
+ *
+ * Optionally, you can select which columns to operate on (see [Selecting Columns][org.jetbrains.kotlinx.dataframe.api.DropNulls.DropNullsSelectingOptions]).
+ *
+ * Also, you can supply `whereAllNull = true` to only drop rows where all selected cells are `null`. By default,
+ * rows are dropped if any of the selected cells are `null`.
+ *
+ * For more information: [See `dropNulls` on the documentation website.](https://kotlin.github.io/dataframe/drop.html#dropnulls)
+ * ### This Drop Nulls Overload
+ * Select columns using [KProperties][KProperty] ([KProperties API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi.KPropertiesApi]).
+ *
+ * #### For example:
+ * ```kotlin
+ * data class Person(val length: Double, val age: Double)
+ * ```
+ *
+ * `df.`[dropNulls][org.jetbrains.kotlinx.dataframe.api.dropNulls]`(Person::length, Person::age)`
+ *
+ * `df.`[dropNulls][dropNulls]`(Person::length, whereAllNull = true)`
+ * @param whereAllNull `false` by default.
+ *   If `true`, rows are dropped if all selected cells are `null`.
+ *   If `false`, rows are dropped if any of the selected cells is `null`.
+ * @param columns The [KProperties][KProperty] used to select the columns of this [DataFrame][org.jetbrains.kotlinx.dataframe.DataFrame] to drop rows in.
+ */
+public fun <T> DataFrame<T>.dropNulls(vararg columns: KProperty<*>, whereAllNull: Boolean = false): DataFrame<T> =
+    dropNulls(whereAllNull) { columns.toColumnSet() }
+
+/**
+ * ## The Drop Nulls Operation
+ *
+ * Removes rows with `null` values. Specific case of [drop][org.jetbrains.kotlinx.dataframe.DataFrame.drop].
+ *
+ * Optionally, you can select which columns to operate on (see [Selecting Columns][org.jetbrains.kotlinx.dataframe.api.DropNulls.DropNullsSelectingOptions]).
+ *
+ * Also, you can supply `whereAllNull = true` to only drop rows where all selected cells are `null`. By default,
+ * rows are dropped if any of the selected cells are `null`.
+ *
+ * For more information: [See `dropNulls` on the documentation website.](https://kotlin.github.io/dataframe/drop.html#dropnulls)
+ * ### This Drop Nulls Overload
+ * Select columns using their [column names][String]
+ * ([String API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi.StringApi]).
+ *
+ * #### For example:
+ *
+ * `df.`[dropNulls][org.jetbrains.kotlinx.dataframe.api.dropNulls]`("length", "age")`
+ *
+ * `df.`[dropNulls][dropNulls]`("length", whereAllNull = true)`
+ * @param whereAllNull `false` by default.
+ *   If `true`, rows are dropped if all selected cells are `null`.
+ *   If `false`, rows are dropped if any of the selected cells is `null`.
+ * @param columns The [Strings][String] corresponding to the names of columns in this [DataFrame][org.jetbrains.kotlinx.dataframe.DataFrame] to drop rows in.
+ */
+public fun <T> DataFrame<T>.dropNulls(vararg columns: String, whereAllNull: Boolean = false): DataFrame<T> =
+    dropNulls(whereAllNull) { columns.toColumnSet() }
+
+/**
+ * ## The Drop Nulls Operation
+ *
+ * Removes rows with `null` values. Specific case of [drop][org.jetbrains.kotlinx.dataframe.DataFrame.drop].
+ *
+ * Optionally, you can select which columns to operate on (see [Selecting Columns][org.jetbrains.kotlinx.dataframe.api.DropNulls.DropNullsSelectingOptions]).
+ *
+ * Also, you can supply `whereAllNull = true` to only drop rows where all selected cells are `null`. By default,
+ * rows are dropped if any of the selected cells are `null`.
+ *
+ * For more information: [See `dropNulls` on the documentation website.](https://kotlin.github.io/dataframe/drop.html#dropnulls)
+ * ### This Drop Nulls Overload
+ * Select columns using [column accessors][org.jetbrains.kotlinx.dataframe.columns.ColumnReference]
+ * ([Column Accessors API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi.ColumnAccessorsApi]).
+ *
+ * #### For example:
+ *
+ * `val length by `[column][org.jetbrains.kotlinx.dataframe.api.column]`<`[Double][Double]`>()`
+ *
+ * `val age by `[column][org.jetbrains.kotlinx.dataframe.api.column]`<`[Double][Double]`>()`
+ *
+ * `df.`[dropNulls][org.jetbrains.kotlinx.dataframe.api.dropNulls]`(length, age)`
+ *
+ * `df.`[dropNulls][dropNulls]`(length, whereAllNull = true)`
+ * @param whereAllNull `false` by default.
+ *   If `true`, rows are dropped if all selected cells are `null`.
+ *   If `false`, rows are dropped if any of the selected cells is `null`.
+ * @param columns The [Column References][org.jetbrains.kotlinx.dataframe.columns.ColumnReference] used to select the columns of this [DataFrame][org.jetbrains.kotlinx.dataframe.DataFrame] to drop rows in.
+ */
+public fun <T> DataFrame<T>.dropNulls(vararg columns: AnyColumnReference, whereAllNull: Boolean = false): DataFrame<T> =
+    dropNulls(whereAllNull) { columns.toColumnSet() }
+
+/**
+ * ## The Drop Nulls Operation
+ *
+ * Removes `null` values from this [DataColumn], adjusting the type accordingly.
+ */
+public fun <T> DataColumn<T?>.dropNulls(): DataColumn<T> =
+    (if (!hasNulls()) this else filter { it != null }) as DataColumn<T>
+
+// endregion
+
+// region dropNA
+
+/**
+ * ## The Drop `NA` Operation
+ *
+ * Removes rows with [`NA`][org.jetbrains.kotlinx.dataframe.documentation.NA] values. Specific case of [drop][org.jetbrains.kotlinx.dataframe.DataFrame.drop].
+ *
+ * Optionally, you can select which columns to operate on (see [Selecting Columns][org.jetbrains.kotlinx.dataframe.api.DropNA.DropNASelectingOptions]).
+ * Also, you can supply `whereAllNA = true` to only drop rows where all selected cells are [`NA`][org.jetbrains.kotlinx.dataframe.documentation.NA]. By default,
+ * rows are dropped if any of the selected cells are [`NA`][org.jetbrains.kotlinx.dataframe.documentation.NA].
+ *
+ * For more information: [See `dropNA` on the documentation website.](https://kotlin.github.io/dataframe/drop.html#dropna)
+ * ### This Drop NA Overload
+ * Select or express columns using the [Columns Selection DSL][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl].
+ * (Any (combination of) [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+ *
+ * This DSL is initiated by a [Columns Selector][org.jetbrains.kotlinx.dataframe.ColumnsSelector] lambda,
+ * which operates in the context of the [Columns Selection DSL][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl] and
+ * expects you to return a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn] or [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] (so, a [ColumnsResolver][org.jetbrains.kotlinx.dataframe.columns.ColumnsResolver]).
+ * This is an entity formed by calling any (combination) of the functions
+ * in the DSL that is or can be resolved into one or more columns.
+ *
+ * #### NOTE:
+ * While you can use the [String API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi.StringApi] and [KProperties API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi.KPropertiesApi]
+ * in this DSL directly with any function, they are NOT valid return types for the
+ * [Columns Selector][org.jetbrains.kotlinx.dataframe.ColumnsSelector] lambda. You'd need to turn them into a [ColumnReference][org.jetbrains.kotlinx.dataframe.columns.ColumnReference] first, for instance
+ * with a function like [`col("name")`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.col].
+ *
+ * ### Check out: [Columns Selection DSL Grammar][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.DslGrammar]
+ *
+ * &nbsp;&nbsp;&nbsp;&nbsp;
+ *
+ * [See Column Selectors on the documentation website.](https://kotlin.github.io/dataframe/columnselectors.html)
+ *
+ * #### For example:
+ *
+ * `df.`[dropNA][org.jetbrains.kotlinx.dataframe.api.dropNA]` { length `[and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]` age }`
+ *
+ * `df.`[dropNA][org.jetbrains.kotlinx.dataframe.api.dropNA]`  {  `[cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`(1..5) }`
+ *
+ * `df.`[dropNA][org.jetbrains.kotlinx.dataframe.api.dropNA]`  {  `[colsOf][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[Double][Double]`>() }`
+ *
+ *
+ * `df.`[dropNA][dropNA]`(whereAllNA = true) { `[colsOf][colsOf]`<`[Double][Double]`>() }`
+ * @param whereAllNA `false` by default.
+ *   If `true`, rows are dropped if all selected cells are [`NA`][org.jetbrains.kotlinx.dataframe.documentation.NA].
+ *   If `false`, rows are dropped if any of the selected cells is [`NA`][org.jetbrains.kotlinx.dataframe.documentation.NA].
+ * @param columns The [Columns Selector][org.jetbrains.kotlinx.dataframe.ColumnsSelector] used to select the columns of this [DataFrame][org.jetbrains.kotlinx.dataframe.DataFrame] to drop rows in.
+ */
+public fun <T> DataFrame<T>.dropNA(whereAllNA: Boolean = false, columns: ColumnsSelector<T, *>): DataFrame<T> {
+    val cols = this[columns]
+    return if (whereAllNA) {
+        drop { cols.all { this[it].isNA } }
+    } else {
+        drop { cols.any { this[it].isNA } }
+    }
+}
+
+/**
+ * ## The Drop `NA` Operation
+ *
+ * Removes rows with [`NA`][org.jetbrains.kotlinx.dataframe.documentation.NA] values. Specific case of [drop][org.jetbrains.kotlinx.dataframe.DataFrame.drop].
+ *
+ * Optionally, you can select which columns to operate on (see [Selecting Columns][org.jetbrains.kotlinx.dataframe.api.DropNA.DropNASelectingOptions]).
+ * Also, you can supply `whereAllNA = true` to only drop rows where all selected cells are [`NA`][org.jetbrains.kotlinx.dataframe.documentation.NA]. By default,
+ * rows are dropped if any of the selected cells are [`NA`][org.jetbrains.kotlinx.dataframe.documentation.NA].
+ *
+ * For more information: [See `dropNA` on the documentation website.](https://kotlin.github.io/dataframe/drop.html#dropna)
+ * ### This Drop NA Overload
+ * Select columns using [KProperties][KProperty] ([KProperties API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi.KPropertiesApi]).
+ *
+ * #### For example:
+ * ```kotlin
+ * data class Person(val length: Double, val age: Double)
+ * ```
+ *
+ * `df.`[dropNA][org.jetbrains.kotlinx.dataframe.api.dropNA]`(Person::length, Person::age)`
+ *
+ * `df.`[dropNA][dropNA]`(Person::length, whereAllNA = true)`
+ * @param whereAllNA `false` by default.
+ *   If `true`, rows are dropped if all selected cells are [`NA`][org.jetbrains.kotlinx.dataframe.documentation.NA].
+ *   If `false`, rows are dropped if any of the selected cells is [`NA`][org.jetbrains.kotlinx.dataframe.documentation.NA].
+ * @param columns The [KProperties][KProperty] used to select the columns of this [DataFrame][org.jetbrains.kotlinx.dataframe.DataFrame] to drop rows in.
+ */
+public fun <T> DataFrame<T>.dropNA(vararg columns: KProperty<*>, whereAllNA: Boolean = false): DataFrame<T> =
+    dropNA(whereAllNA) { columns.toColumnSet() }
+
+/**
+ * ## The Drop `NA` Operation
+ *
+ * Removes rows with [`NA`][org.jetbrains.kotlinx.dataframe.documentation.NA] values. Specific case of [drop][org.jetbrains.kotlinx.dataframe.DataFrame.drop].
+ *
+ * Optionally, you can select which columns to operate on (see [Selecting Columns][org.jetbrains.kotlinx.dataframe.api.DropNA.DropNASelectingOptions]).
+ * Also, you can supply `whereAllNA = true` to only drop rows where all selected cells are [`NA`][org.jetbrains.kotlinx.dataframe.documentation.NA]. By default,
+ * rows are dropped if any of the selected cells are [`NA`][org.jetbrains.kotlinx.dataframe.documentation.NA].
+ *
+ * For more information: [See `dropNA` on the documentation website.](https://kotlin.github.io/dataframe/drop.html#dropna)
+ * ### This Drop NA Overload
+ * Select columns using their [column names][String]
+ * ([String API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi.StringApi]).
+ *
+ * #### For example:
+ *
+ * `df.`[dropNA][org.jetbrains.kotlinx.dataframe.api.dropNA]`("length", "age")`
+ *
+ * `df.`[dropNA][dropNA]`("length", whereAllNA = true)`
+ * @param whereAllNA `false` by default.
+ *   If `true`, rows are dropped if all selected cells are [`NA`][org.jetbrains.kotlinx.dataframe.documentation.NA].
+ *   If `false`, rows are dropped if any of the selected cells is [`NA`][org.jetbrains.kotlinx.dataframe.documentation.NA].
+ * @param columns The [Strings][String] corresponding to the names of columns in this [DataFrame][org.jetbrains.kotlinx.dataframe.DataFrame] to drop rows in.
+ */
+public fun <T> DataFrame<T>.dropNA(vararg columns: String, whereAllNA: Boolean = false): DataFrame<T> =
+    dropNA(whereAllNA) { columns.toColumnSet() }
+
+/**
+ * ## The Drop `NA` Operation
+ *
+ * Removes rows with [`NA`][org.jetbrains.kotlinx.dataframe.documentation.NA] values. Specific case of [drop][org.jetbrains.kotlinx.dataframe.DataFrame.drop].
+ *
+ * Optionally, you can select which columns to operate on (see [Selecting Columns][org.jetbrains.kotlinx.dataframe.api.DropNA.DropNASelectingOptions]).
+ * Also, you can supply `whereAllNA = true` to only drop rows where all selected cells are [`NA`][org.jetbrains.kotlinx.dataframe.documentation.NA]. By default,
+ * rows are dropped if any of the selected cells are [`NA`][org.jetbrains.kotlinx.dataframe.documentation.NA].
+ *
+ * For more information: [See `dropNA` on the documentation website.](https://kotlin.github.io/dataframe/drop.html#dropna)
+ * ### This Drop NA Overload
+ * Select columns using [column accessors][org.jetbrains.kotlinx.dataframe.columns.ColumnReference]
+ * ([Column Accessors API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi.ColumnAccessorsApi]).
+ *
+ * #### For example:
+ *
+ * `val length by `[column][org.jetbrains.kotlinx.dataframe.api.column]`<`[Double][Double]`>()`
+ *
+ * `val age by `[column][org.jetbrains.kotlinx.dataframe.api.column]`<`[Double][Double]`>()`
+ *
+ * `df.`[dropNA][org.jetbrains.kotlinx.dataframe.api.dropNA]`(length, age)`
+ *
+ * `df.`[dropNA][dropNA]`(length, whereAllNA = true)`
+ * @param whereAllNA `false` by default.
+ *   If `true`, rows are dropped if all selected cells are [`NA`][org.jetbrains.kotlinx.dataframe.documentation.NA].
+ *   If `false`, rows are dropped if any of the selected cells is [`NA`][org.jetbrains.kotlinx.dataframe.documentation.NA].
+ * @param columns The [Column References][org.jetbrains.kotlinx.dataframe.columns.ColumnReference] used to select the columns of this [DataFrame][org.jetbrains.kotlinx.dataframe.DataFrame] to drop rows in.
+ */
+public fun <T> DataFrame<T>.dropNA(vararg columns: AnyColumnReference, whereAllNA: Boolean = false): DataFrame<T> =
+    dropNA(whereAllNA) { columns.toColumnSet() }
+
+/**
+ * ## The Drop `NA` Operation
+ *
+ * Removes rows with [`NA`][org.jetbrains.kotlinx.dataframe.documentation.NA] values. Specific case of [drop][org.jetbrains.kotlinx.dataframe.DataFrame.drop].
+ *
+ * Optionally, you can select which columns to operate on (see [Selecting Columns][org.jetbrains.kotlinx.dataframe.api.DropNA.DropNASelectingOptions]).
+ * Also, you can supply `whereAllNA = true` to only drop rows where all selected cells are [`NA`][org.jetbrains.kotlinx.dataframe.documentation.NA]. By default,
+ * rows are dropped if any of the selected cells are [`NA`][org.jetbrains.kotlinx.dataframe.documentation.NA].
+ *
+ * For more information: [See `dropNA` on the documentation website.](https://kotlin.github.io/dataframe/drop.html#dropna)
+ * ### This Drop NA Overload
+ * This overload operates on all columns in the [DataFrame].
+ * @param whereAllNA `false` by default.
+ *   If `true`, rows are dropped if all selected cells are [`NA`][org.jetbrains.kotlinx.dataframe.documentation.NA].
+ *   If `false`, rows are dropped if any of the selected cells is [`NA`][org.jetbrains.kotlinx.dataframe.documentation.NA].
+ */
+public fun <T> DataFrame<T>.dropNA(whereAllNA: Boolean = false): DataFrame<T> = dropNA(whereAllNA) { all() }
+
+/**
+ * ## The Drop `NA` Operation
+ *
+ * Removes [`NA`][NA] values from this [DataColumn], adjusting the type accordingly.
+ */
+public fun <T> DataColumn<T?>.dropNA(): DataColumn<T> =
+    when (typeClass) {
+        Double::class, Float::class -> filter { !it.isNA }.cast()
+        else -> (if (!hasNulls()) this else filter { it != null }) as DataColumn<T>
+    }
+
+// endregion
+
+// region dropNaNs
+
+/**
+ * ## The Drop `NaN` Operation
+ *
+ * Removes rows with [`NaN`][Double.isNaN] values. Specific case of [drop][org.jetbrains.kotlinx.dataframe.DataFrame.drop].
+ *
+ * Optionally, you can select which columns to operate on (see [Selecting Columns][org.jetbrains.kotlinx.dataframe.api.DropNaNs.DropNaNsSelectingOptions]).
+ * Also, you can supply `whereAllNaN = true` to only drop rows where all selected cells are [`NaN`][Double.isNaN]. By default,
+ * rows are dropped if any of the selected cells are [`NaN`][Double.isNaN].
+ *
+ * For more information: [See `dropNaNs` on the documentation website.](https://kotlin.github.io/dataframe/drop.html#dropnans)
+ * ### This Drop NaNs Overload
+ * Select or express columns using the [Columns Selection DSL][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl].
+ * (Any (combination of) [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+ *
+ * This DSL is initiated by a [Columns Selector][org.jetbrains.kotlinx.dataframe.ColumnsSelector] lambda,
+ * which operates in the context of the [Columns Selection DSL][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl] and
+ * expects you to return a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn] or [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] (so, a [ColumnsResolver][org.jetbrains.kotlinx.dataframe.columns.ColumnsResolver]).
+ * This is an entity formed by calling any (combination) of the functions
+ * in the DSL that is or can be resolved into one or more columns.
+ *
+ * #### NOTE:
+ * While you can use the [String API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi.StringApi] and [KProperties API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi.KPropertiesApi]
+ * in this DSL directly with any function, they are NOT valid return types for the
+ * [Columns Selector][org.jetbrains.kotlinx.dataframe.ColumnsSelector] lambda. You'd need to turn them into a [ColumnReference][org.jetbrains.kotlinx.dataframe.columns.ColumnReference] first, for instance
+ * with a function like [`col("name")`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.col].
+ *
+ * ### Check out: [Columns Selection DSL Grammar][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.DslGrammar]
+ *
+ * &nbsp;&nbsp;&nbsp;&nbsp;
+ *
+ * [See Column Selectors on the documentation website.](https://kotlin.github.io/dataframe/columnselectors.html)
+ *
+ * #### For example:
+ *
+ * `df.`[dropNaNs][org.jetbrains.kotlinx.dataframe.api.dropNaNs]` { length `[and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]` age }`
+ *
+ * `df.`[dropNaNs][org.jetbrains.kotlinx.dataframe.api.dropNaNs]`  {  `[cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`(1..5) }`
+ *
+ * `df.`[dropNaNs][org.jetbrains.kotlinx.dataframe.api.dropNaNs]`  {  `[colsOf][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[Double][Double]`>() }`
+ *
+ *
+ * `df.`[dropNaNs][dropNaNs]`(whereAllNaN = true) { `[colsOf][colsOf]`<`[Double][Double]`>() }`
+ * @param whereAllNaN `false` by default.
+ *   If `true`, rows are dropped if all selected cells are [`NaN`][Double.isNaN].
+ *   If `false`, rows are dropped if any of the selected cells is [`NaN`][Double.isNaN].
+ * @param columns The [Columns Selector][org.jetbrains.kotlinx.dataframe.ColumnsSelector] used to select the columns of this [DataFrame][org.jetbrains.kotlinx.dataframe.DataFrame] to drop rows in.
+ */
+public fun <T> DataFrame<T>.dropNaNs(whereAllNaN: Boolean = false, columns: ColumnsSelector<T, *>): DataFrame<T> {
+    val cols = this[columns]
+    return if (whereAllNaN) {
+        drop { cols.all { this[it].isNaN } }
+    } else {
+        drop { cols.any { this[it].isNaN } }
+    }
+}
+
+/**
+ * ## The Drop `NaN` Operation
+ *
+ * Removes rows with [`NaN`][Double.isNaN] values. Specific case of [drop][org.jetbrains.kotlinx.dataframe.DataFrame.drop].
+ *
+ * Optionally, you can select which columns to operate on (see [Selecting Columns][org.jetbrains.kotlinx.dataframe.api.DropNaNs.DropNaNsSelectingOptions]).
+ * Also, you can supply `whereAllNaN = true` to only drop rows where all selected cells are [`NaN`][Double.isNaN]. By default,
+ * rows are dropped if any of the selected cells are [`NaN`][Double.isNaN].
+ *
+ * For more information: [See `dropNaNs` on the documentation website.](https://kotlin.github.io/dataframe/drop.html#dropnans)
+ * ### This Drop NaNs Overload
+ * Select columns using [KProperties][KProperty] ([KProperties API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi.KPropertiesApi]).
+ *
+ * #### For example:
+ * ```kotlin
+ * data class Person(val length: Double, val age: Double)
+ * ```
+ *
+ * `df.`[dropNaNs][org.jetbrains.kotlinx.dataframe.api.dropNaNs]`(Person::length, Person::age)`
+ *
+ * `df.`[dropNaNs][dropNaNs]`(Person::length, whereAllNaN = true)`
+ * @param whereAllNaN `false` by default.
+ *   If `true`, rows are dropped if all selected cells are [`NaN`][Double.isNaN].
+ *   If `false`, rows are dropped if any of the selected cells is [`NaN`][Double.isNaN].
+ * @param columns The [KProperties][KProperty] used to select the columns of this [DataFrame][org.jetbrains.kotlinx.dataframe.DataFrame] to drop rows in.
+ */
+public fun <T> DataFrame<T>.dropNaNs(vararg columns: KProperty<*>, whereAllNaN: Boolean = false): DataFrame<T> =
+    dropNaNs(whereAllNaN) { columns.toColumnSet() }
+
+/**
+ * ## The Drop `NaN` Operation
+ *
+ * Removes rows with [`NaN`][Double.isNaN] values. Specific case of [drop][org.jetbrains.kotlinx.dataframe.DataFrame.drop].
+ *
+ * Optionally, you can select which columns to operate on (see [Selecting Columns][org.jetbrains.kotlinx.dataframe.api.DropNaNs.DropNaNsSelectingOptions]).
+ * Also, you can supply `whereAllNaN = true` to only drop rows where all selected cells are [`NaN`][Double.isNaN]. By default,
+ * rows are dropped if any of the selected cells are [`NaN`][Double.isNaN].
+ *
+ * For more information: [See `dropNaNs` on the documentation website.](https://kotlin.github.io/dataframe/drop.html#dropnans)
+ * ### This Drop NaNs Overload
+ * Select columns using their [column names][String]
+ * ([String API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi.StringApi]).
+ *
+ * #### For example:
+ *
+ * `df.`[dropNaNs][org.jetbrains.kotlinx.dataframe.api.dropNaNs]`("length", "age")`
+ *
+ * `df.`[dropNaNs][dropNaNs]`("length", whereAllNaN = true)`
+ * @param whereAllNaN `false` by default.
+ *   If `true`, rows are dropped if all selected cells are [`NaN`][Double.isNaN].
+ *   If `false`, rows are dropped if any of the selected cells is [`NaN`][Double.isNaN].
+ * @param columns The [Strings][String] corresponding to the names of columns in this [DataFrame][org.jetbrains.kotlinx.dataframe.DataFrame] to drop rows in.
+ */
+public fun <T> DataFrame<T>.dropNaNs(vararg columns: String, whereAllNaN: Boolean = false): DataFrame<T> =
+    dropNaNs(whereAllNaN) { columns.toColumnSet() }
+
+/**
+ * ## The Drop `NaN` Operation
+ *
+ * Removes rows with [`NaN`][Double.isNaN] values. Specific case of [drop][org.jetbrains.kotlinx.dataframe.DataFrame.drop].
+ *
+ * Optionally, you can select which columns to operate on (see [Selecting Columns][org.jetbrains.kotlinx.dataframe.api.DropNaNs.DropNaNsSelectingOptions]).
+ * Also, you can supply `whereAllNaN = true` to only drop rows where all selected cells are [`NaN`][Double.isNaN]. By default,
+ * rows are dropped if any of the selected cells are [`NaN`][Double.isNaN].
+ *
+ * For more information: [See `dropNaNs` on the documentation website.](https://kotlin.github.io/dataframe/drop.html#dropnans)
+ * ### This Drop NaNs Overload
+ * Select columns using [column accessors][org.jetbrains.kotlinx.dataframe.columns.ColumnReference]
+ * ([Column Accessors API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi.ColumnAccessorsApi]).
+ *
+ * #### For example:
+ *
+ * `val length by `[column][org.jetbrains.kotlinx.dataframe.api.column]`<`[Double][Double]`>()`
+ *
+ * `val age by `[column][org.jetbrains.kotlinx.dataframe.api.column]`<`[Double][Double]`>()`
+ *
+ * `df.`[dropNaNs][org.jetbrains.kotlinx.dataframe.api.dropNaNs]`(length, age)`
+ *
+ * `df.`[dropNaNs][dropNaNs]`(length, whereAllNaN = true)`
+ * @param whereAllNaN `false` by default.
+ *   If `true`, rows are dropped if all selected cells are [`NaN`][Double.isNaN].
+ *   If `false`, rows are dropped if any of the selected cells is [`NaN`][Double.isNaN].
+ * @param columns The [Column References][org.jetbrains.kotlinx.dataframe.columns.ColumnReference] used to select the columns of this [DataFrame][org.jetbrains.kotlinx.dataframe.DataFrame] to drop rows in.
+ */
+public fun <T> DataFrame<T>.dropNaNs(vararg columns: AnyColumnReference, whereAllNaN: Boolean = false): DataFrame<T> =
+    dropNaNs(whereAllNaN) { columns.toColumnSet() }
+
+/**
+ * ## The Drop `NaN` Operation
+ *
+ * Removes rows with [`NaN`][Double.isNaN] values. Specific case of [drop][org.jetbrains.kotlinx.dataframe.DataFrame.drop].
+ *
+ * Optionally, you can select which columns to operate on (see [Selecting Columns][org.jetbrains.kotlinx.dataframe.api.DropNaNs.DropNaNsSelectingOptions]).
+ * Also, you can supply `whereAllNaN = true` to only drop rows where all selected cells are [`NaN`][Double.isNaN]. By default,
+ * rows are dropped if any of the selected cells are [`NaN`][Double.isNaN].
+ *
+ * For more information: [See `dropNaNs` on the documentation website.](https://kotlin.github.io/dataframe/drop.html#dropnans)
+ * ### This Drop NaNs Overload
+ * This overload operates on all columns in the [DataFrame].
+ * @param whereAllNaN `false` by default.
+ *   If `true`, rows are dropped if all selected cells are [`NaN`][Double.isNaN].
+ *   If `false`, rows are dropped if any of the selected cells is [`NaN`][Double.isNaN].
+ */
+public fun <T> DataFrame<T>.dropNaNs(whereAllNaN: Boolean = false): DataFrame<T> = dropNaNs(whereAllNaN) { all() }
+
+/**
+ * ## The Drop `NaN` Operation
+ *
+ * Removes [`NaN`][NaN] values from this [DataColumn], adjusting the type accordingly.
+ */
+public fun <T> DataColumn<T>.dropNaNs(): DataColumn<T> =
+    when (typeClass) {
+        Double::class, Float::class -> filter { !it.isNaN }.cast()
+        else -> this
+    }
+
+// endregion
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/TypeConversions.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/TypeConversions.kt
new file mode 100644
index 000000000..a6ff75634
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/TypeConversions.kt
@@ -0,0 +1,413 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import org.jetbrains.kotlinx.dataframe.AnyBaseCol
+import org.jetbrains.kotlinx.dataframe.AnyCol
+import org.jetbrains.kotlinx.dataframe.AnyFrame
+import org.jetbrains.kotlinx.dataframe.AnyRow
+import org.jetbrains.kotlinx.dataframe.ColumnGroupAccessor
+import org.jetbrains.kotlinx.dataframe.ColumnSelector
+import org.jetbrains.kotlinx.dataframe.DataColumn
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.DataRow
+import org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor
+import org.jetbrains.kotlinx.dataframe.columns.ColumnGroup
+import org.jetbrains.kotlinx.dataframe.columns.ColumnPath
+import org.jetbrains.kotlinx.dataframe.columns.ColumnReference
+import org.jetbrains.kotlinx.dataframe.columns.ColumnSet
+import org.jetbrains.kotlinx.dataframe.columns.FrameColumn
+import org.jetbrains.kotlinx.dataframe.columns.SingleColumn
+import org.jetbrains.kotlinx.dataframe.columns.ValueColumn
+import org.jetbrains.kotlinx.dataframe.impl.GroupByImpl
+import org.jetbrains.kotlinx.dataframe.impl.anyNull
+import org.jetbrains.kotlinx.dataframe.impl.asList
+import org.jetbrains.kotlinx.dataframe.impl.columnName
+import org.jetbrains.kotlinx.dataframe.impl.columns.ColumnAccessorImpl
+import org.jetbrains.kotlinx.dataframe.impl.columns.asAnyFrameColumn
+import org.jetbrains.kotlinx.dataframe.impl.columns.asValues
+import org.jetbrains.kotlinx.dataframe.impl.columns.forceResolve
+import org.jetbrains.kotlinx.dataframe.impl.owner
+import org.jetbrains.kotlinx.dataframe.index
+import kotlin.reflect.KProperty
+import kotlin.reflect.typeOf
+
+// region String
+
+public fun String.toColumnAccessor(): ColumnAccessor<Any?> = ColumnAccessorImpl(this)
+
+public fun <T> String.toColumnOf(): ColumnAccessor<T> = ColumnAccessorImpl(this)
+
+// endregion
+
+// region ColumnPath
+
+public fun <T> ColumnPath.toColumnOf(): ColumnAccessor<T> = ColumnAccessorImpl(this)
+
+public fun ColumnPath.toColumnAccessor(): ColumnAccessor<Any?> = ColumnAccessorImpl(this)
+
+public fun ColumnPath.toColumnGroupAccessor(): ColumnAccessor<AnyRow> = ColumnAccessorImpl(this)
+
+public fun ColumnPath.toFrameColumnAccessor(): ColumnAccessor<AnyFrame> = ColumnAccessorImpl(this)
+
+// endregion
+
+// region ColumnReference
+
+public fun <T> ColumnReference<T>.toColumnAccessor(): ColumnAccessor<T> =
+    when (this) {
+        is ColumnAccessor<T> -> this
+        else -> ColumnAccessorImpl(path())
+    }
+
+// endregion
+
+// region KProperty
+
+public fun <T> KProperty<T>.toColumnAccessor(): ColumnAccessor<T> = ColumnAccessorImpl<T>(columnName)
+
+// endregion
+
+// region DataColumn
+
+public fun AnyBaseCol.toDataFrame(): AnyFrame = dataFrameOf(listOf(this))
+
+@JvmName("asNumberAnyNullable")
+public fun DataColumn<Any?>.asNumbers(): ValueColumn<Number?> {
+    require(isNumber())
+    return this.asValues()
+}
+
+@JvmName("asNumberAny")
+public fun DataColumn<Any>.asNumbers(): ValueColumn<Number> {
+    require(isNumber())
+    return this as ValueColumn<Number>
+}
+
+public fun <T> DataColumn<T>.asComparable(): DataColumn<Comparable<T>> {
+    require(isComparable())
+    return this as DataColumn<Comparable<T>>
+}
+
+public fun <T> ColumnReference<T?>.castToNotNullable(): ColumnReference<T> = cast()
+
+public fun <T> DataColumn<T?>.castToNotNullable(): DataColumn<T> {
+    require(!hasNulls()) { "Column `$name` has nulls" }
+    return this as DataColumn<T>
+}
+
+public fun <T> DataColumn<T>.castToNullable(): DataColumn<T?> = cast()
+
+public fun <T> ColumnReference<T>.castToNullable(): ColumnReference<T?> = cast()
+
+public fun AnyCol.setNullable(nullable: Boolean): AnyCol =
+    if (nullable) {
+        this.castToNullable()
+    } else {
+        this.castToNotNullable()
+    }
+
+// region to array
+
+public inline fun <reified T> DataColumn<T>.toTypedArray(): Array<T> = toList().toTypedArray()
+
+public fun DataColumn<Number>.toFloatArray(): FloatArray = convertToFloat().toList().toFloatArray()
+
+public fun DataColumn<Number>.toDoubleArray(): DoubleArray = convertToDouble().toList().toDoubleArray()
+
+public fun DataColumn<Number>.toIntArray(): IntArray = convertToInt().toList().toIntArray()
+
+public fun DataColumn<Number>.toLongArray(): LongArray = convertToLong().toList().toLongArray()
+
+public fun DataColumn<Number>.toShortArray(): ShortArray = convertTo<Short>().toList().toShortArray()
+
+public fun DataColumn<Number>.toByteArray(): ByteArray = convertTo<Byte>().toList().toByteArray()
+
+// endregion
+
+public fun AnyCol.asValueColumn(): ValueColumn<*> = this as ValueColumn<*>
+
+@JvmName("asColumnGroupUntyped")
+public fun AnyCol.asColumnGroup(): ColumnGroup<*> = this as ColumnGroup<*>
+
+@JvmName("asFrameColumnUntyped")
+public fun AnyCol.asFrameColumn(): FrameColumn<*> = this as FrameColumn<*>
+
+public fun <T> DataColumn<DataFrame<T>>.asFrameColumn(): FrameColumn<T> =
+    (this as AnyCol).asAnyFrameColumn().castFrameColumn()
+
+@JvmName("asGroupedT")
+public fun <T> DataColumn<DataRow<T>>.asColumnGroup(): ColumnGroup<T> = (this as AnyCol).asColumnGroup().cast()
+
+public fun <T> DataColumn<DataRow<T>>.asDataFrame(): DataFrame<T> = asColumnGroup()
+
+// endregion
+
+// region ColumnGroup
+
+public fun <T> ColumnGroup<T>.asDataColumn(): DataColumn<DataRow<T>> = this as DataColumn<DataRow<T>>
+
+public fun <T> ColumnGroup<T>.asDataFrame(): DataFrame<T> = this
+
+// endregion
+
+// region SingleColumn
+
+/**
+ * ## As ColumnGroup
+ *
+ * Creates a [ColumnAccessor][ColumnAccessor]`<`[DataRow][DataRow]`<`[C][C]`>>` from [this][this].
+ * This is especially useful when you want to use [ColumnGroup] functions in the [ColumnsSelectionDsl] but your column
+ * type is not recognized as a [ColumnGroup].
+ * If you're not sure whether a column is recognized as [ColumnGroup] or not, you can always call [asColumnGroup][asColumnGroup]
+ * and it will return the same type if it is already a [ColumnGroup].
+ *
+ * NOTE: This does not check whether the column is actually a [ColumnGroup] or not. It just casts it.
+ *
+ * #### For example:
+ *
+ * `df.`[select][DataFrame.select]` { `[first][ColumnsSelectionDsl.first]`().`[asColumnGroup][SingleColumn.asColumnGroup]`().`[firstCol][ColumnsSelectionDsl.firstCol]`() }`
+ *
+ * @receiver The column reference to cast to a [SingleColumn]`<`[DataRow][DataRow]`<`[C][C]`>>`.
+ * @param [C] The type of the (group) column.
+ * @return A [SingleColumn]`<`[DataRow][DataRow]`<`[C][C]`>>`.
+ */
+private interface SingleColumnAsColumnGroupDocs
+
+/** ## As ColumnGroup
+ *
+ * Creates a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor]`<`[DataRow][org.jetbrains.kotlinx.dataframe.DataRow]`<`[C][C]`>>` from [this][this].
+ * This is especially useful when you want to use [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup] functions in the [ColumnsSelectionDsl][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl] but your column
+ * type is not recognized as a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+ * If you're not sure whether a column is recognized as [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup] or not, you can always call [asColumnGroup][asColumnGroup]
+ * and it will return the same type if it is already a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+ *
+ * NOTE: This does not check whether the column is actually a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup] or not. It just casts it.
+ *
+ * #### For example:
+ *
+ * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { `[first][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.first]`().`[asColumnGroup][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.asColumnGroup]`().`[firstCol][org.jetbrains.kotlinx.dataframe.api.FirstColumnsSelectionDsl.firstCol]`() }`
+ *
+ * @receiver The column reference to cast to a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]`<`[DataRow][org.jetbrains.kotlinx.dataframe.DataRow]`<`[C][C]`>>`.
+ * @param [C] The type of the (group) column.
+ * @return A [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]`<`[DataRow][org.jetbrains.kotlinx.dataframe.DataRow]`<`[C][C]`>>`. */
+@Suppress("UNCHECKED_CAST")
+public fun <C> SingleColumn<C>.asColumnGroup(): SingleColumn<DataRow<C>> = this as SingleColumn<DataRow<C>>
+
+/** ## As ColumnGroup
+ *
+ * Creates a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor]`<`[DataRow][org.jetbrains.kotlinx.dataframe.DataRow]`<`[C][C]`>>` from [this][this].
+ * This is especially useful when you want to use [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup] functions in the [ColumnsSelectionDsl][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl] but your column
+ * type is not recognized as a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+ * If you're not sure whether a column is recognized as [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup] or not, you can always call [asColumnGroup][asColumnGroup]
+ * and it will return the same type if it is already a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+ *
+ * NOTE: This does not check whether the column is actually a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup] or not. It just casts it.
+ *
+ * #### For example:
+ *
+ * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { `[first][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.first]`().`[asColumnGroup][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.asColumnGroup]`().`[firstCol][org.jetbrains.kotlinx.dataframe.api.FirstColumnsSelectionDsl.firstCol]`() }`
+ *
+ * @receiver The column reference to cast to a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]`<`[DataRow][org.jetbrains.kotlinx.dataframe.DataRow]`<`[C][C]`>>`.
+ * @param [C] The type of the (group) column.
+ * @return A [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]`<`[DataRow][org.jetbrains.kotlinx.dataframe.DataRow]`<`[C][C]`>>`. */
+@JvmName("asColumnGroupDataRow")
+public fun <C> SingleColumn<DataRow<C>>.asColumnGroup(): SingleColumn<DataRow<C>> = this
+
+// endregion
+
+// region FrameColumn
+
+public fun <T> FrameColumn<T>.asDataColumn(): DataColumn<DataFrame<T>?> = this
+
+public fun <T> FrameColumn<T>.toValueColumn(): ValueColumn<DataFrame<T>?> =
+    DataColumn.createValueColumn(name, toList(), type())
+
+// endregion
+
+// region ColumnSet
+
+@JvmName("asNumbersAny")
+public fun ColumnSet<Any>.asNumbers(): ColumnSet<Number> = this as ColumnSet<Number>
+
+@JvmName("asNumbersAny")
+public fun SingleColumn<Any>.asNumbers(): SingleColumn<Number> = this as SingleColumn<Number>
+
+@JvmName("asNumbersAnyNullable")
+public fun ColumnSet<Any?>.asNumbers(): ColumnSet<Number?> = this as ColumnSet<Number?>
+
+@JvmName("asNumbersAnyNullable")
+public fun SingleColumn<Any?>.asNumbers(): SingleColumn<Number?> = this as SingleColumn<Number?>
+
+public fun <T> ColumnSet<T>.asComparable(): ColumnSet<Comparable<T>> = this as ColumnSet<Comparable<T>>
+
+public fun <T> SingleColumn<T>.asComparable(): SingleColumn<Comparable<T>> = this as SingleColumn<Comparable<T>>
+
+// endregion
+
+// region Iterable
+
+public fun <T> Iterable<DataFrame<T>>.toFrameColumn(name: String = ""): FrameColumn<T> =
+    DataColumn.createFrameColumn(name, asList()).forceResolve()
+
+public inline fun <reified T> Iterable<T>.toValueColumn(name: String = ""): ValueColumn<T> =
+    DataColumn.createValueColumn(name, asList()).forceResolve()
+
+public inline fun <reified T> Iterable<T>.toValueColumn(column: ColumnAccessor<T>): ValueColumn<T> =
+    toValueColumn(column.name())
+
+public inline fun <reified T> Iterable<T>.toValueColumn(column: KProperty<T>): ValueColumn<T> =
+    toValueColumn(column.columnName)
+
+/**
+ * Indicates how [DataColumn.type] should be calculated.
+ *
+ * Used in [add], [insert], [convert], [map], [merge], [split] and other [DataFrame] operations
+ */
+public enum class Infer {
+
+    /**
+     * Use reified type argument of an inline [DataFrame] operation as [DataColumn.type].
+     */
+    None,
+
+    /**
+     * Use reified type argument of an inline [DataFrame] operation as [DataColumn.type], but compute [DataColumn.hasNulls] by checking column [DataColumn.values] for an actual presence of *null* values.
+     */
+    Nulls,
+
+    /**
+     * Infer [DataColumn.type] and [DataColumn.hasNulls] from actual [DataColumn.values] using optionally provided base type as an upper bound.
+     */
+    Type,
+
+    ;
+
+    /**
+     * @param [infer] [An enum][Infer] that indicates how [DataColumn.type] should be calculated.
+     * Either [None], [Nulls], or [Type].
+     */
+    internal interface ParamDoc
+}
+
+/**
+ * Indicates how [DataColumn.hasNulls] (or, more accurately, DataColumn.type.isMarkedNullable) should be initialized from
+ * expected schema and actual data when reading schema-defined data formats.
+ */
+public enum class NullabilityOptions {
+    /**
+     * Use only actual data, set [DataColumn.hasNulls] to true if and only if there are null values in the column.
+     * On empty dataset use False.
+     */
+    Infer,
+
+    /**
+     * Set [DataColumn.hasNulls] to expected value. Throw exception if column should be not nullable but there are null values.
+     */
+    Checking,
+
+    /**
+     * Set [DataColumn.hasNulls] to expected value by default. Change False to True if column should be not nullable but there are null values.
+     */
+    Widening,
+}
+
+public class NullabilityException : Exception()
+
+/**
+ * @return if column should be marked nullable for current [NullabilityOptions] value with actual [data] and [expectedNulls] per some schema/signature.
+ * @throws [NullabilityException] for [NullabilityOptions.Checking] if [expectedNulls] is false and [data] contains nulls.
+ */
+public fun NullabilityOptions.applyNullability(data: List<Any?>, expectedNulls: Boolean): Boolean {
+    val hasNulls = data.anyNull()
+    return when (this) {
+        NullabilityOptions.Infer -> hasNulls
+
+        NullabilityOptions.Checking -> {
+            if (!expectedNulls && hasNulls) {
+                throw NullabilityException()
+            }
+            expectedNulls
+        }
+
+        NullabilityOptions.Widening -> {
+            expectedNulls || hasNulls
+        }
+    }
+}
+
+public inline fun <reified T> Iterable<T>.toColumn(name: String = "", infer: Infer = Infer.Nulls): DataColumn<T> =
+    if (infer == Infer.Type) {
+        DataColumn.createWithTypeInference(name, asList())
+    } else {
+        DataColumn.create(name, asList(), typeOf<T>(), infer)
+    }.forceResolve()
+
+public inline fun <reified T> Iterable<*>.toColumnOf(name: String = ""): DataColumn<T> =
+    DataColumn.create(name, asList() as List<T>, typeOf<T>()).forceResolve()
+
+public inline fun <reified T> Iterable<T>.toColumn(ref: ColumnReference<T>): DataColumn<T> =
+    DataColumn.create(ref.name(), asList()).forceResolve()
+
+public inline fun <reified T> Iterable<T>.toColumn(property: KProperty<T>): DataColumn<T> =
+    DataColumn.create(property.columnName, asList()).forceResolve()
+
+public fun Iterable<String>.toPath(): ColumnPath = ColumnPath(asList())
+
+public fun Iterable<AnyBaseCol>.toColumnGroup(name: String): ColumnGroup<*> = dataFrameOf(this).asColumnGroup(name)
+
+public fun <T> Iterable<AnyBaseCol>.toColumnGroup(column: ColumnGroupAccessor<T>): ColumnGroup<T> =
+    dataFrameOf(this).cast<T>().asColumnGroup(column)
+
+public fun <T> Iterable<AnyBaseCol>.toColumnGroupOf(name: String): ColumnGroup<T> = toColumnGroup(name).cast()
+
+// endregion
+
+// region DataFrame
+
+public fun AnyFrame.toMap(): Map<String, List<Any?>> = columns().associateBy({ it.name }, { it.toList() })
+
+public fun <T> DataFrame<T>.asColumnGroup(name: String = ""): ColumnGroup<T> =
+    when (this) {
+        is ColumnGroup<T> -> rename(name)
+        else -> DataColumn.createColumnGroup(name, this)
+    }
+
+public fun <T> DataFrame<T>.asColumnGroup(column: ColumnGroupAccessor<T>): ColumnGroup<T> = asColumnGroup(column.name)
+
+// region as GroupedDataFrame
+
+public fun <T> DataFrame<T>.asGroupBy(groupedColumnName: String): GroupBy<T, T> =
+    GroupByImpl(this, getFrameColumn(groupedColumnName).castFrameColumn()) { none() }
+
+public fun <T, G> DataFrame<T>.asGroupBy(groupedColumn: ColumnReference<DataFrame<G>>): GroupBy<T, G> =
+    GroupByImpl(this, getFrameColumn(groupedColumn.name()).castFrameColumn()) { none() }
+
+public fun <T> DataFrame<T>.asGroupBy(): GroupBy<T, T> {
+    val groupCol = columns().single { it.isFrameColumn() }.asAnyFrameColumn().castFrameColumn<T>()
+    return asGroupBy { groupCol }
+}
+
+public fun <T, G> DataFrame<T>.asGroupBy(selector: ColumnSelector<T, DataFrame<G>>): GroupBy<T, G> {
+    val column = getColumn(selector).asFrameColumn()
+    return GroupByImpl(this, column) { none() }
+}
+
+// endregion
+
+// endregion
+
+// region DataRow
+
+public fun <T> DataRow<T>.toDataFrame(): DataFrame<T> = owner[index..index]
+
+public fun AnyRow.toMap(): Map<String, Any?> = df().columns().associate { it.name() to it[index] }
+
+// endregion
+
+// region Array
+
+public inline fun <reified T> Array<T>.toValueColumn(name: String): ValueColumn<T> =
+    DataColumn.createValueColumn(name, this.asList(), typeOf<T>())
+
+public fun Array<out String>.toPath(): ColumnPath = ColumnPath(this.asList())
+
+// endregion
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/add.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/add.kt
new file mode 100644
index 000000000..50cc00d03
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/add.kt
@@ -0,0 +1,252 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import org.jetbrains.kotlinx.dataframe.AnyBaseCol
+import org.jetbrains.kotlinx.dataframe.AnyCol
+import org.jetbrains.kotlinx.dataframe.AnyColumnGroupAccessor
+import org.jetbrains.kotlinx.dataframe.AnyColumnReference
+import org.jetbrains.kotlinx.dataframe.AnyFrame
+import org.jetbrains.kotlinx.dataframe.AnyRow
+import org.jetbrains.kotlinx.dataframe.ColumnsContainer
+import org.jetbrains.kotlinx.dataframe.DataColumn
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.DataRow
+import org.jetbrains.kotlinx.dataframe.RowExpression
+import org.jetbrains.kotlinx.dataframe.Selector
+import org.jetbrains.kotlinx.dataframe.annotations.Interpretable
+import org.jetbrains.kotlinx.dataframe.annotations.Refine
+import org.jetbrains.kotlinx.dataframe.columns.BaseColumn
+import org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor
+import org.jetbrains.kotlinx.dataframe.columns.ColumnPath
+import org.jetbrains.kotlinx.dataframe.columns.ColumnReference
+import org.jetbrains.kotlinx.dataframe.exceptions.DuplicateColumnNamesException
+import org.jetbrains.kotlinx.dataframe.exceptions.UnequalColumnSizesException
+import org.jetbrains.kotlinx.dataframe.impl.api.insertImpl
+import org.jetbrains.kotlinx.dataframe.impl.columns.resolveSingle
+import kotlin.reflect.KProperty
+
+/*
+ * `add` operation adds new columns to DataFrame.
+ */
+
+// region Add existing columns
+
+/**
+ * Creates new [DataFrame] with given columns added to the end of original [DataFrame.columns] list.
+ *
+ * Original [DataFrame] is not modified.
+ *
+ * @param columns columns to add
+ * @throws [DuplicateColumnNamesException] if columns in expected result have repeated names
+ * @throws [UnequalColumnSizesException] if columns in expected result have different sizes
+ * @return new [DataFrame] with added columns
+ */
+public fun <T> DataFrame<T>.add(vararg columns: AnyBaseCol): DataFrame<T> = addAll(columns.asIterable())
+
+/**
+ * Creates new [DataFrame] with given columns added to the end of original [DataFrame.columns] list.
+ *
+ * Original [DataFrame] is not modified.
+ *
+ * @param columns columns to add
+ * @throws [DuplicateColumnNamesException] if columns in expected result have repeated names
+ * @throws [UnequalColumnSizesException] if columns in expected result have different sizes
+ * @return new [DataFrame] with added columns
+ */
+public fun <T> DataFrame<T>.addAll(columns: Iterable<AnyBaseCol>): DataFrame<T> =
+    dataFrameOf(columns() + columns).cast()
+
+/**
+ * Creates new [DataFrame] with all columns from given [dataFrames] added to the end of original [DataFrame.columns] list.
+ *
+ * Original [DataFrame] is not modified.
+ *
+ * @param dataFrames dataFrames to get columns from
+ * @throws [DuplicateColumnNamesException] if columns in expected result have repeated names
+ * @throws [UnequalColumnSizesException] if columns in expected result have different sizes
+ * @return new [DataFrame] with added columns
+ */
+public fun <T> DataFrame<T>.add(vararg dataFrames: AnyFrame): DataFrame<T> = addAll(dataFrames.asIterable())
+
+/**
+ * Creates new [DataFrame] with all columns from given [dataFrames] added to the end of original [DataFrame.columns] list.
+ *
+ * Original [DataFrame] is not modified.
+ *
+ * @param dataFrames dataFrames to get columns from
+ * @throws [DuplicateColumnNamesException] if columns in expected result have repeated names
+ * @throws [UnequalColumnSizesException] if columns in expected result have different sizes
+ * @return new [DataFrame] with added columns
+ */
+@JvmName("addAllFrames")
+public fun <T> DataFrame<T>.addAll(dataFrames: Iterable<AnyFrame>): DataFrame<T> =
+    addAll(dataFrames.flatMap { it.columns() })
+
+// endregion
+
+// region Create and add a single column
+
+/**
+ * Receiver that is used by the [AddExpression] (for instance in the [add] and [update] operations)
+ * to access new (added or updated) column value in preceding row.
+ */
+public interface AddDataRow<out T> : DataRow<T> {
+
+    /**
+     * Returns a new value that was already computed for some preceding row during current [add] or [update] column operation.
+     *
+     * Can be used to compute series of values with recurrence relations, e.g. fibonacci.
+     *
+     * @throws IndexOutOfBoundsException when called on a successive row that doesn't have new value yet
+     */
+    public fun <C> AnyRow.newValue(): C
+}
+
+/**
+ * [AddExpression] is used to express or select any instance of `R` using the given instance of [AddDataRow]`<T>` as
+ * `this` and `it`.
+ *
+ * Shorthand for:
+ * ```kotlin
+ * AddDataRow<T>.(it: AddDataRow<T>) -> R
+ * ```
+ */
+public typealias AddExpression<T, R> = Selector<AddDataRow<T>, R>
+
+/**
+ * Creates new column using row [expression] and adds it to the end of [DataFrame]
+ *
+ * Original [DataFrame] is not modified.
+ *
+ * @param name name for a new column. If it is empty, a unique column name will be generated. Otherwise, it should be unique for original [DataFrame].
+ * @param infer a value of [Infer] that specifies how to compute column [type][BaseColumn.type] for a new column
+ * @param expression [AddExpression] that computes column value for every [DataRow]
+ * @return new [DataFrame] with added column
+ * @throws DuplicateColumnNamesException if [DataFrame] already contains a column with given [name]
+ */
+@Refine
+@Interpretable("Add")
+public inline fun <reified R, T> DataFrame<T>.add(
+    name: String,
+    infer: Infer = Infer.Nulls,
+    noinline expression: AddExpression<T, R>,
+): DataFrame<T> = (this + mapToColumn(name, infer, expression))
+
+public inline fun <reified R, T> DataFrame<T>.add(
+    property: KProperty<R>,
+    infer: Infer = Infer.Nulls,
+    noinline expression: AddExpression<T, R>,
+): DataFrame<T> = (this + mapToColumn(property, infer, expression))
+
+public inline fun <reified R, T> DataFrame<T>.add(
+    column: ColumnAccessor<R>,
+    infer: Infer = Infer.Nulls,
+    noinline expression: AddExpression<T, R>,
+): DataFrame<T> = add(column.path(), infer, expression)
+
+public inline fun <reified R, T> DataFrame<T>.add(
+    path: ColumnPath,
+    infer: Infer = Infer.Nulls,
+    noinline expression: AddExpression<T, R>,
+): DataFrame<T> {
+    val col = mapToColumn(path.name(), infer, expression)
+    if (path.size == 1) return this + col
+    return insertImpl(path, col)
+}
+
+// endregion
+
+// region Create and add several columns
+
+public class AddDsl<T>(
+    @PublishedApi internal val df: DataFrame<T>,
+) : ColumnsContainer<T> by df,
+    ColumnSelectionDsl<T> {
+
+    // TODO: support adding column into path
+    internal val columns = mutableListOf<AnyCol>()
+
+    public fun add(column: AnyColumnReference): Boolean = columns.add(column.resolveSingle(df)!!.data)
+
+    public operator fun AnyColumnReference.unaryPlus(): Boolean = add(this)
+
+    public operator fun String.unaryPlus(): Boolean = add(df[this])
+
+    @PublishedApi
+    internal inline fun <reified R> add(
+        name: String,
+        infer: Infer = Infer.Nulls,
+        noinline expression: RowExpression<T, R>,
+    ): Boolean = add(df.mapToColumn(name, infer, expression))
+
+    public inline fun <reified R> expr(
+        infer: Infer = Infer.Nulls,
+        noinline expression: RowExpression<T, R>,
+    ): DataColumn<R> = df.mapToColumn("", infer, expression)
+
+    @Interpretable("From")
+    public inline infix fun <reified R> String.from(noinline expression: RowExpression<T, R>): Boolean =
+        add(this, Infer.Nulls, expression)
+
+    // TODO: use path instead of name
+    public inline infix fun <reified R> ColumnAccessor<R>.from(noinline expression: RowExpression<T, R>): Boolean =
+        name().from(expression)
+
+    public inline infix fun <reified R> KProperty<R>.from(noinline expression: RowExpression<T, R>): Boolean =
+        add(name, Infer.Nulls, expression)
+
+    public infix fun String.from(column: AnyColumnReference): Boolean = add(column.rename(this))
+
+    public inline infix fun <reified R> ColumnAccessor<R>.from(column: ColumnReference<R>): Boolean = name() from column
+
+    public inline infix fun <reified R> KProperty<R>.from(column: ColumnReference<R>): Boolean = name from column
+
+    @Interpretable("Into")
+    public infix fun AnyColumnReference.into(name: String): Boolean = add(rename(name))
+
+    public infix fun <R> ColumnReference<R>.into(column: ColumnAccessor<R>): Boolean = into(column.name())
+
+    public infix fun <R> ColumnReference<R>.into(column: KProperty<R>): Boolean = into(column.name)
+
+    @Interpretable("AddDslStringInvoke")
+    public operator fun String.invoke(body: AddDsl<T>.() -> Unit): Unit = group(this, body)
+
+    public infix fun AnyColumnGroupAccessor.from(body: AddDsl<T>.() -> Unit): Unit = group(this, body)
+
+    public fun group(column: AnyColumnGroupAccessor, body: AddDsl<T>.() -> Unit): Unit = group(column.name(), body)
+
+    public fun group(name: String, body: AddDsl<T>.() -> Unit) {
+        val dsl = AddDsl(df)
+        body(dsl)
+        add(dsl.columns.toColumnGroup(name))
+    }
+
+    public fun group(body: AddDsl<T>.() -> Unit): AddGroup<T> = AddGroup(body)
+
+    public infix fun AddGroup<T>.into(groupName: String): Unit = group(groupName, body)
+
+    public infix fun AddGroup<T>.into(column: AnyColumnGroupAccessor): Unit = into(column.name())
+}
+
+@Refine
+@Interpretable("AddWithDsl")
+public fun <T> DataFrame<T>.add(body: AddDsl<T>.() -> Unit): DataFrame<T> {
+    val dsl = AddDsl(this)
+    body(dsl)
+    return dataFrameOf(this@add.columns() + dsl.columns).cast()
+}
+
+public inline fun <reified R, T, G> GroupBy<T, G>.add(
+    name: String,
+    infer: Infer = Infer.Nulls,
+    noinline expression: RowExpression<G, R>,
+): GroupBy<T, G> = updateGroups { add(name, infer, expression) }
+
+public inline fun <reified R, T, G> GroupBy<T, G>.add(
+    column: ColumnAccessor<G>,
+    infer: Infer = Infer.Nulls,
+    noinline expression: RowExpression<G, R>,
+): GroupBy<T, G> = add(column.name(), infer, expression)
+
+public class AddGroup<T>(internal val body: AddDsl<T>.() -> Unit)
+
+// endregion
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/addId.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/addId.kt
new file mode 100644
index 000000000..d29f697ab
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/addId.kt
@@ -0,0 +1,24 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import org.jetbrains.kotlinx.dataframe.AnyCol
+import org.jetbrains.kotlinx.dataframe.AnyFrame
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.annotations.Interpretable
+import org.jetbrains.kotlinx.dataframe.annotations.Refine
+import org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor
+
+// region DataColumn
+
+public fun AnyCol.addId(columnName: String = "id"): AnyFrame = toDataFrame().addId(columnName)
+
+// endregion
+
+// region DataFrame
+
+public fun <T> DataFrame<T>.addId(column: ColumnAccessor<Int>): DataFrame<T> = insert(column) { index() }.at(0)
+
+@Refine
+@Interpretable("AddId")
+public fun <T> DataFrame<T>.addId(columnName: String = "id"): DataFrame<T> = insert(columnName) { index() }.at(0)
+
+// endregion
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/aggregate.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/aggregate.kt
new file mode 100644
index 000000000..0c592a431
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/aggregate.kt
@@ -0,0 +1,24 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.DataRow
+import org.jetbrains.kotlinx.dataframe.Selector
+import org.jetbrains.kotlinx.dataframe.aggregation.AggregateDsl
+import org.jetbrains.kotlinx.dataframe.aggregation.AggregateGroupedBody
+import org.jetbrains.kotlinx.dataframe.annotations.Interpretable
+import org.jetbrains.kotlinx.dataframe.annotations.Refine
+import org.jetbrains.kotlinx.dataframe.impl.aggregateGroupBy
+
+// region Pivot
+
+public fun <T, R> Pivot<T>.aggregate(separate: Boolean = false, body: Selector<AggregateDsl<T>, R>): DataRow<T> =
+    delegate {
+        aggregate(separate, body)
+    }
+
+// endregion
+
+@Refine
+@Interpretable("Aggregate")
+public fun <T, R> Grouped<T>.aggregate(body: AggregateGroupedBody<T, R>): DataFrame<T> =
+    aggregateGroupBy((this as GroupBy<*, *>).toDataFrame(), { groups.cast() }, removeColumns = true, body).cast<T>()
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/all.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/all.kt
new file mode 100644
index 000000000..465b5b56b
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/all.kt
@@ -0,0 +1,8141 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import org.jetbrains.kotlinx.dataframe.AnyCol
+import org.jetbrains.kotlinx.dataframe.AnyColumnReference
+import org.jetbrains.kotlinx.dataframe.AnyRow
+import org.jetbrains.kotlinx.dataframe.ColumnFilter
+import org.jetbrains.kotlinx.dataframe.ColumnSelector
+import org.jetbrains.kotlinx.dataframe.DataColumn
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.DataRow
+import org.jetbrains.kotlinx.dataframe.Predicate
+import org.jetbrains.kotlinx.dataframe.RowFilter
+import org.jetbrains.kotlinx.dataframe.annotations.Interpretable
+import org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.Grammar
+import org.jetbrains.kotlinx.dataframe.columns.ColumnGroup
+import org.jetbrains.kotlinx.dataframe.columns.ColumnPath
+import org.jetbrains.kotlinx.dataframe.columns.ColumnSet
+import org.jetbrains.kotlinx.dataframe.columns.ColumnWithPath
+import org.jetbrains.kotlinx.dataframe.columns.ColumnsResolver
+import org.jetbrains.kotlinx.dataframe.columns.SingleColumn
+import org.jetbrains.kotlinx.dataframe.columns.isSingleColumnWithGroup
+import org.jetbrains.kotlinx.dataframe.columns.size
+import org.jetbrains.kotlinx.dataframe.columns.values
+import org.jetbrains.kotlinx.dataframe.impl.columns.TransformableColumnSet
+import org.jetbrains.kotlinx.dataframe.impl.columns.addPath
+import org.jetbrains.kotlinx.dataframe.impl.columns.onResolve
+import org.jetbrains.kotlinx.dataframe.impl.columns.transform
+import org.jetbrains.kotlinx.dataframe.impl.owner
+import kotlin.reflect.KProperty
+
+// region DataColumn
+
+/** Returns `true` if all [values] match the given [predicate] or [values] is empty. */
+public fun <T> DataColumn<T>.all(predicate: Predicate<T>): Boolean = values.all(predicate)
+
+/** Returns `true` if all [values] are `null` or [values] is empty. */
+public fun <C> DataColumn<C>.allNulls(): Boolean = size == 0 || all { it == null }
+
+// endregion
+
+// region DataRow
+
+public fun AnyRow.allNA(): Boolean = owner.columns().all { it[index()].isNA }
+
+// endregion
+
+// region DataFrame
+
+/** Returns `true` if all [rows] match the given [predicate] or [rows] is empty. */
+public fun <T> DataFrame<T>.all(predicate: RowFilter<T>): Boolean = rows().all { predicate(it, it) }
+
+// endregion
+
+// region ColumnsSelectionDsl
+
+/**
+ * ## All Flavors of All (Cols) [Columns Selection DSL][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl]
+ *
+ * See [Grammar] for all functions in this interface.
+ * @param _UNUSED [#KT-68546](https://youtrack.jetbrains.com/issue/KT-68546/Conflicting-overloads-in-non-generic-interface-K2-2.0.0)
+ */
+public interface AllColumnsSelectionDsl<out _UNUSED> {
+
+    /**
+     * ## Grammar of All Flavors of All (Cols):
+     *
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * [(What is this notation?)][org.jetbrains.kotlinx.dataframe.documentation.DslGrammar]
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  ### Definitions:
+     *  `columnSet: `[`ColumnSet`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]`<*>`
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  `columnGroup: `[`SingleColumn`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]`<`[`DataRow`][org.jetbrains.kotlinx.dataframe.DataRow]`<*>> | `[`String`][String]`  |  `[`KProperty`][kotlin.reflect.KProperty]`<* | `[`DataRow`][org.jetbrains.kotlinx.dataframe.DataRow]`<*>> | `[`ColumnPath`][org.jetbrains.kotlinx.dataframe.columns.ColumnPath]
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  `column: `[`ColumnAccessor`][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor]`  |  `[`String`][String]`  | `[`KProperty`][kotlin.reflect.KProperty]`<*> | `[`ColumnPath`][org.jetbrains.kotlinx.dataframe.columns.ColumnPath]
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  `colSelector: `[`ColumnSelector`][org.jetbrains.kotlinx.dataframe.ColumnSelector]
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  `condition: `[`ColumnFilter`][org.jetbrains.kotlinx.dataframe.ColumnFilter]
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  ### What can be called directly in the [Columns Selection DSL][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl]:
+     *
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  [**`all`**][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.all]**`()`**
+     *
+     *  `| `**`all`**`(`[**`Before`**][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsBefore]`|`[**`After`**][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.allAfter]`|`[**`From`**][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsFrom]`|`[**`UpTo`**][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsUpTo]`) ( `**`(`**[`column`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ColumnDef]**`)`**`  |  `**`{ `**[`colSelector`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ColumnSelectorDef]**` }`**` )`
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  ### What can be called on a [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]:
+     *
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  [`columnSet`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ColumnSetDef]
+     *
+     *  &nbsp;&nbsp;&nbsp;&nbsp;__`.`__[**`all`**][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.all]**`()`**
+     *
+     *  &nbsp;&nbsp;&nbsp;&nbsp;`| `**`.all`**`(`[**`Before`**][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsBefore]`|`[**`After`**][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.allAfter]`|`[**`From`**][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsFrom]`|`[**`UpTo`**][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsUpTo]`) ( `**`(`**[`column`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ColumnDef]**`)`**`  |  `**`{ `**[`condition`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ConditionDef]**` }`**` )`
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  ### What can be called on a [Column Group (reference)][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ColumnGroupDef]:
+     *
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  [`columnGroup`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ColumnGroupDef]
+     *
+     *  &nbsp;&nbsp;&nbsp;&nbsp;__`.`__[**`allCols`**][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allCols]**`()`**
+     *
+     *  &nbsp;&nbsp;&nbsp;&nbsp;`| `**`.allCols`**`(`[**`Before`**][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsBefore]`|`[**`After`**][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.allAfter]`|`[**`From`**][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsFrom]`|`[**`UpTo`**][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsUpTo]`) ( `**`(`**[`column`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ColumnDef]**`)`**`  |  `**`{ `**[`colSelector`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ColumnSelectorDef]**` }`**` )`
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     */
+    public interface Grammar {
+
+        /** [**`all`**][ColumnsSelectionDsl.all] */
+        public interface PlainDslName
+
+        /** __`.`__[**`all`**][ColumnsSelectionDsl.all] */
+        public interface ColumnSetName
+
+        /** __`.`__[**`allCols`**][ColumnsSelectionDsl.allCols] */
+        public interface ColumnGroupName
+
+        /** [**`Before`**][ColumnsSelectionDsl.allColsBefore] */
+        public interface Before
+
+        /** [**`After`**][ColumnsSelectionDsl.allAfter] */
+        public interface After
+
+        /** [**`From`**][ColumnsSelectionDsl.allColsFrom] */
+        public interface From
+
+        /** [**`UpTo`**][ColumnsSelectionDsl.allColsUpTo] */
+        public interface UpTo
+    }
+
+    // region all
+
+    /**
+     * ## All (Cols)
+     *
+     * Creates a new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] that contains all columns from [this],
+     * the opposite of [none][org.jetbrains.kotlinx.dataframe.api.NoneColumnsSelectionDsl.none].
+     *
+     * This makes the function equivalent to [cols()][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols] without filter.
+     *
+     * This function operates solely on columns at the top-level.
+     *
+     * NOTE: For [column groups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup], `all` is named `allCols` instead to avoid confusion.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     * `df.`[move][org.jetbrains.kotlinx.dataframe.DataFrame.move]`  {  `[all][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.all]`() }.`[under][org.jetbrains.kotlinx.dataframe.api.MoveClause.under]`("info")`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myGroup.`[allCols][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.allCols]`() }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][DataFrame.select]`  {  `[cols][ColumnsSelectionDsl.cols]`  { "a" in  `[name][ColumnWithPath.name]` }.`[all][ColumnSet.all]`() }`
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * NOTE: This is an identity call and can be omitted in most cases.
+     *
+     * #### Flavors of All (Cols):
+     *
+     * - [`all(Cols)`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allCols]`()`:
+     *     All columns
+     *
+     * - [`all(Cols)Before`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsBefore]`(column)`:
+     *     All columns before the specified column, excluding that column
+     *
+     * - [`all(Cols)After`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsAfter]`(column)`:
+     *     All columns after the specified column, excluding that column
+     *
+     * - [`all(Cols)From`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsFrom]`(column)`:
+     *     All columns from the specified column, including that column
+     *
+     * - [`all(Cols)UpTo`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsUpTo]`(column)`:
+     *     All columns up to the specified column, including that column
+     *
+     * @see [ColumnsSelectionDsl.rangeTo]
+     * @see [ColumnsSelectionDsl.allBefore]
+     * @see [ColumnsSelectionDsl.allAfter]
+     * @see [ColumnsSelectionDsl.allFrom]
+     * @see [ColumnsSelectionDsl.allUpTo]
+     * @see [ColumnsSelectionDsl.allExcept]
+     * @see [ColumnsSelectionDsl.cols]
+     */
+    @Suppress("UNCHECKED_CAST")
+    public fun <C> ColumnSet<C>.all(): TransformableColumnSet<C> = allColumnsInternal() as TransformableColumnSet<C>
+
+    /**
+     * ## All (Cols)
+     *
+     * Creates a new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] that contains all columns from [this],
+     * the opposite of [none][org.jetbrains.kotlinx.dataframe.api.NoneColumnsSelectionDsl.none].
+     *
+     * This makes the function equivalent to [cols()][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols] without filter.
+     *
+     * This function operates solely on columns at the top-level.
+     *
+     * NOTE: For [column groups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup], `all` is named `allCols` instead to avoid confusion.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     * `df.`[move][org.jetbrains.kotlinx.dataframe.DataFrame.move]`  {  `[all][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.all]`() }.`[under][org.jetbrains.kotlinx.dataframe.api.MoveClause.under]`("info")`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myGroup.`[allCols][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.allCols]`() }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][DataFrame.select]`  {  `[all][ColumnsSelectionDsl.all]`() }`
+     *
+     * #### Flavors of All (Cols):
+     *
+     * - [`all(Cols)`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allCols]`()`:
+     *     All columns
+     *
+     * - [`all(Cols)Before`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsBefore]`(column)`:
+     *     All columns before the specified column, excluding that column
+     *
+     * - [`all(Cols)After`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsAfter]`(column)`:
+     *     All columns after the specified column, excluding that column
+     *
+     * - [`all(Cols)From`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsFrom]`(column)`:
+     *     All columns from the specified column, including that column
+     *
+     * - [`all(Cols)UpTo`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsUpTo]`(column)`:
+     *     All columns up to the specified column, including that column
+     *
+     * @see [ColumnsSelectionDsl.rangeTo]
+     * @see [ColumnsSelectionDsl.allBefore]
+     * @see [ColumnsSelectionDsl.allAfter]
+     * @see [ColumnsSelectionDsl.allFrom]
+     * @see [ColumnsSelectionDsl.allUpTo]
+     * @see [ColumnsSelectionDsl.allExcept]
+     * @see [ColumnsSelectionDsl.cols]
+     */
+    @Interpretable("All0")
+    public fun ColumnsSelectionDsl<*>.all(): TransformableColumnSet<*> = asSingleColumn().allColumnsInternal()
+
+    /**
+     * ## All (Cols)
+     *
+     * Creates a new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] that contains all columns from [this],
+     * the opposite of [none][org.jetbrains.kotlinx.dataframe.api.NoneColumnsSelectionDsl.none].
+     *
+     * This makes the function equivalent to [cols()][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols] without filter.
+     *
+     * This function operates solely on columns at the top-level.
+     *
+     * NOTE: For [column groups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup], `all` is named `allCols` instead to avoid confusion.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     * `df.`[move][org.jetbrains.kotlinx.dataframe.DataFrame.move]`  {  `[all][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.all]`() }.`[under][org.jetbrains.kotlinx.dataframe.api.MoveClause.under]`("info")`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myGroup.`[allCols][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.allCols]`() }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][DataFrame.select]` { myGroup.`[allCols][SingleColumn.allCols]`() }`
+     *
+     * #### Flavors of All (Cols):
+     *
+     * - [`all(Cols)`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allCols]`()`:
+     *     All columns
+     *
+     * - [`all(Cols)Before`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsBefore]`(column)`:
+     *     All columns before the specified column, excluding that column
+     *
+     * - [`all(Cols)After`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsAfter]`(column)`:
+     *     All columns after the specified column, excluding that column
+     *
+     * - [`all(Cols)From`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsFrom]`(column)`:
+     *     All columns from the specified column, including that column
+     *
+     * - [`all(Cols)UpTo`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsUpTo]`(column)`:
+     *     All columns up to the specified column, including that column
+     *
+     * @see [ColumnsSelectionDsl.rangeTo]
+     * @see [ColumnsSelectionDsl.allBefore]
+     * @see [ColumnsSelectionDsl.allAfter]
+     * @see [ColumnsSelectionDsl.allFrom]
+     * @see [ColumnsSelectionDsl.allUpTo]
+     * @see [ColumnsSelectionDsl.allExcept]
+     * @see [ColumnsSelectionDsl.cols]
+     */
+    public fun SingleColumn<DataRow<*>>.allCols(): TransformableColumnSet<*> =
+        ensureIsColumnGroup().allColumnsInternal()
+
+    /**
+     * ## All (Cols)
+     *
+     * Creates a new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] that contains all columns from [this],
+     * the opposite of [none][org.jetbrains.kotlinx.dataframe.api.NoneColumnsSelectionDsl.none].
+     *
+     * This makes the function equivalent to [cols()][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols] without filter.
+     *
+     * This function operates solely on columns at the top-level.
+     *
+     * NOTE: For [column groups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup], `all` is named `allCols` instead to avoid confusion.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     * `df.`[move][org.jetbrains.kotlinx.dataframe.DataFrame.move]`  {  `[all][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.all]`() }.`[under][org.jetbrains.kotlinx.dataframe.api.MoveClause.under]`("info")`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myGroup.`[allCols][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.allCols]`() }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][DataFrame.select]` { "myGroupCol".`[allCols][String.allCols]`() }`
+     *
+     * #### Flavors of All (Cols):
+     *
+     * - [`all(Cols)`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allCols]`()`:
+     *     All columns
+     *
+     * - [`all(Cols)Before`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsBefore]`(column)`:
+     *     All columns before the specified column, excluding that column
+     *
+     * - [`all(Cols)After`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsAfter]`(column)`:
+     *     All columns after the specified column, excluding that column
+     *
+     * - [`all(Cols)From`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsFrom]`(column)`:
+     *     All columns from the specified column, including that column
+     *
+     * - [`all(Cols)UpTo`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsUpTo]`(column)`:
+     *     All columns up to the specified column, including that column
+     *
+     * @see [ColumnsSelectionDsl.rangeTo]
+     * @see [ColumnsSelectionDsl.allBefore]
+     * @see [ColumnsSelectionDsl.allAfter]
+     * @see [ColumnsSelectionDsl.allFrom]
+     * @see [ColumnsSelectionDsl.allUpTo]
+     * @see [ColumnsSelectionDsl.allExcept]
+     * @see [ColumnsSelectionDsl.cols]
+     */
+    public fun String.allCols(): TransformableColumnSet<*> = columnGroup(this).allCols()
+
+    /**
+     * ## All (Cols)
+     *
+     * Creates a new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] that contains all columns from [this],
+     * the opposite of [none][org.jetbrains.kotlinx.dataframe.api.NoneColumnsSelectionDsl.none].
+     *
+     * This makes the function equivalent to [cols()][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols] without filter.
+     *
+     * This function operates solely on columns at the top-level.
+     *
+     * NOTE: For [column groups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup], `all` is named `allCols` instead to avoid confusion.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     * `df.`[move][org.jetbrains.kotlinx.dataframe.DataFrame.move]`  {  `[all][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.all]`() }.`[under][org.jetbrains.kotlinx.dataframe.api.MoveClause.under]`("info")`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myGroup.`[allCols][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.allCols]`() }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][DataFrame.select]` { DataSchemaType::columnGroup.`[allCols][KProperty.allCols]`() }`
+     *
+     * #### Flavors of All (Cols):
+     *
+     * - [`all(Cols)`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allCols]`()`:
+     *     All columns
+     *
+     * - [`all(Cols)Before`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsBefore]`(column)`:
+     *     All columns before the specified column, excluding that column
+     *
+     * - [`all(Cols)After`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsAfter]`(column)`:
+     *     All columns after the specified column, excluding that column
+     *
+     * - [`all(Cols)From`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsFrom]`(column)`:
+     *     All columns from the specified column, including that column
+     *
+     * - [`all(Cols)UpTo`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsUpTo]`(column)`:
+     *     All columns up to the specified column, including that column
+     *
+     * @see [ColumnsSelectionDsl.rangeTo]
+     * @see [ColumnsSelectionDsl.allBefore]
+     * @see [ColumnsSelectionDsl.allAfter]
+     * @see [ColumnsSelectionDsl.allFrom]
+     * @see [ColumnsSelectionDsl.allUpTo]
+     * @see [ColumnsSelectionDsl.allExcept]
+     * @see [ColumnsSelectionDsl.cols]
+     */
+    public fun KProperty<*>.allCols(): TransformableColumnSet<*> = columnGroup(this).allCols()
+
+    /**
+     * ## All (Cols)
+     *
+     * Creates a new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] that contains all columns from [this],
+     * the opposite of [none][org.jetbrains.kotlinx.dataframe.api.NoneColumnsSelectionDsl.none].
+     *
+     * This makes the function equivalent to [cols()][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols] without filter.
+     *
+     * This function operates solely on columns at the top-level.
+     *
+     * NOTE: For [column groups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup], `all` is named `allCols` instead to avoid confusion.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     * `df.`[move][org.jetbrains.kotlinx.dataframe.DataFrame.move]`  {  `[all][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.all]`() }.`[under][org.jetbrains.kotlinx.dataframe.api.MoveClause.under]`("info")`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myGroup.`[allCols][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.allCols]`() }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][DataFrame.select]` { "pathTo"["myGroup"].`[allCols][ColumnPath.allCols]`() }`
+     *
+     * #### Flavors of All (Cols):
+     *
+     * - [`all(Cols)`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allCols]`()`:
+     *     All columns
+     *
+     * - [`all(Cols)Before`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsBefore]`(column)`:
+     *     All columns before the specified column, excluding that column
+     *
+     * - [`all(Cols)After`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsAfter]`(column)`:
+     *     All columns after the specified column, excluding that column
+     *
+     * - [`all(Cols)From`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsFrom]`(column)`:
+     *     All columns from the specified column, including that column
+     *
+     * - [`all(Cols)UpTo`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsUpTo]`(column)`:
+     *     All columns up to the specified column, including that column
+     *
+     * @see [ColumnsSelectionDsl.rangeTo]
+     * @see [ColumnsSelectionDsl.allBefore]
+     * @see [ColumnsSelectionDsl.allAfter]
+     * @see [ColumnsSelectionDsl.allFrom]
+     * @see [ColumnsSelectionDsl.allUpTo]
+     * @see [ColumnsSelectionDsl.allExcept]
+     * @see [ColumnsSelectionDsl.cols]
+     */
+    public fun ColumnPath.allCols(): TransformableColumnSet<*> = columnGroup(this).allCols()
+
+    // endregion
+
+    // region allAfter
+
+    /**
+     * ## All (Cols) After
+     *
+     * Creates a new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] that contains a subset of columns from [this],
+     * containing all columns after [column], excluding [column] itself.
+     *
+     * [column] can be specified both relative to the current [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup] or the outer scope and
+     * can be referenced using any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi].
+     *
+     * If [column] does not exist, the function will return an empty [ColumnSet][ColumnSet].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * NOTE: Using the `{}` overloads of these functions requires a [ColumnSelector][org.jetbrains.kotlinx.dataframe.ColumnSelector]
+     * in the Plain DSL and on [column groups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     * On [ColumnSets][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] it requires a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter] instead.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[allAfter][ColumnsSelectionDsl.allAfter]`("someColumn") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup]`(Type::myColGroup).`[allColsAfter][SingleColumn.allColsAfter]`(someColumn) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsOf][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[Int][Int]`>().`[allAfter][ColumnSet.allAfter]`(Type::someColumn) }`
+     *
+     * #### Examples for this overload:
+     *
+     *
+     *
+     * #### Flavors of All (Cols):
+     *
+     * - [`all(Cols)`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allCols]`()`:
+     *     All columns
+     *
+     * - [`all(Cols)Before`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsBefore]`(column)`:
+     *     All columns before the specified column, excluding that column
+     *
+     * - [`all(Cols)After`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsAfter]`(column)`:
+     *     All columns after the specified column, excluding that column
+     *
+     * - [`all(Cols)From`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsFrom]`(column)`:
+     *     All columns from the specified column, including that column
+     *
+     * - [`all(Cols)UpTo`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsUpTo]`(column)`:
+     *     All columns up to the specified column, including that column
+     *
+     * @return A new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns after [column], excluding [column] itself.
+     * @see [allBefore]
+     * @see [allAfter]
+     * @see [allFrom]
+     * @see [allUpTo]
+     * @see [ColumnsSelectionDsl.allExcept]
+     * @see [all]
+     * @see [cols]
+     * @param [column] The specified column after which all columns should be taken. This column can be referenced
+     *   to both relatively to the current [ColumnsResolver] and absolutely.
+     */
+    private interface AllAfterDocs
+
+    /** ## All (Cols) After
+     *
+     * Creates a new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] that contains a subset of columns from [this],
+     * containing all columns after [column], excluding [column] itself.
+     *
+     * [column] can be specified both relative to the current [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup] or the outer scope and
+     * can be referenced using any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi].
+     *
+     * If [column] does not exist, the function will return an empty [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * NOTE: Using the `{}` overloads of these functions requires a [ColumnSelector][org.jetbrains.kotlinx.dataframe.ColumnSelector]
+     * in the Plain DSL and on [column groups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     * On [ColumnSets][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] it requires a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter] instead.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[allAfter][ColumnsSelectionDsl.allAfter]`("someColumn") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup]`(Type::myColGroup).`[allColsAfter][SingleColumn.allColsAfter]`(someColumn) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsOf][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[Int][Int]`>().`[allAfter][ColumnSet.allAfter]`(Type::someColumn) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]` { .. }.`[allAfter][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.allAfter]` { myColumn `[in][String.contains]` it.`[name][ColumnWithPath.name]` } }`
+     *
+     * #### Flavors of All (Cols):
+     *
+     * - [`all(Cols)`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allCols]`()`:
+     *     All columns
+     *
+     * - [`all(Cols)Before`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsBefore]`(column)`:
+     *     All columns before the specified column, excluding that column
+     *
+     * - [`all(Cols)After`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsAfter]`(column)`:
+     *     All columns after the specified column, excluding that column
+     *
+     * - [`all(Cols)From`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsFrom]`(column)`:
+     *     All columns from the specified column, including that column
+     *
+     * - [`all(Cols)UpTo`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsUpTo]`(column)`:
+     *     All columns up to the specified column, including that column
+     *
+     * @return A new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns after [column], excluding [column] itself.
+     * @see [allBefore]
+     * @see [allAfter]
+     * @see [allFrom]
+     * @see [allUpTo]
+     * @see [ColumnsSelectionDsl.allExcept]
+     * @see [all]
+     * @see [cols]
+     * @param [column] The specified column after which all columns should be taken. This column can be referenced
+     *   to both relatively to the current [ColumnsResolver][org.jetbrains.kotlinx.dataframe.columns.ColumnsResolver] and absolutely.
+     */
+    @Suppress("UNCHECKED_CAST")
+    public fun <C> ColumnSet<C>.allAfter(column: ColumnFilter<C>): ColumnSet<C> =
+        allAfterInternal(column as ColumnFilter<*>) as ColumnSet<C>
+
+    /** ## All (Cols) After
+     *
+     * Creates a new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] that contains a subset of columns from [this],
+     * containing all columns after [column], excluding [column] itself.
+     *
+     * [column] can be specified both relative to the current [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup] or the outer scope and
+     * can be referenced using any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi].
+     *
+     * If [column] does not exist, the function will return an empty [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * NOTE: Using the `{}` overloads of these functions requires a [ColumnSelector][org.jetbrains.kotlinx.dataframe.ColumnSelector]
+     * in the Plain DSL and on [column groups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     * On [ColumnSets][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] it requires a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter] instead.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[allAfter][ColumnsSelectionDsl.allAfter]`("someColumn") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup]`(Type::myColGroup).`[allColsAfter][SingleColumn.allColsAfter]`(someColumn) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsOf][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[Int][Int]`>().`[allAfter][ColumnSet.allAfter]`(Type::someColumn) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]` { .. }.`[allAfter][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.allAfter]`("pathTo"["myColumn"]) }`
+     *
+     * #### Flavors of All (Cols):
+     *
+     * - [`all(Cols)`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allCols]`()`:
+     *     All columns
+     *
+     * - [`all(Cols)Before`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsBefore]`(column)`:
+     *     All columns before the specified column, excluding that column
+     *
+     * - [`all(Cols)After`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsAfter]`(column)`:
+     *     All columns after the specified column, excluding that column
+     *
+     * - [`all(Cols)From`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsFrom]`(column)`:
+     *     All columns from the specified column, including that column
+     *
+     * - [`all(Cols)UpTo`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsUpTo]`(column)`:
+     *     All columns up to the specified column, including that column
+     *
+     * @return A new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns after [column], excluding [column] itself.
+     * @see [allBefore]
+     * @see [allAfter]
+     * @see [allFrom]
+     * @see [allUpTo]
+     * @see [ColumnsSelectionDsl.allExcept]
+     * @see [all]
+     * @see [cols]
+     * @param [column] The specified column after which all columns should be taken. This column can be referenced
+     *   to both relatively to the current [ColumnsResolver][org.jetbrains.kotlinx.dataframe.columns.ColumnsResolver] and absolutely.
+     */
+    @Suppress("UNCHECKED_CAST")
+    public fun <C> ColumnSet<C>.allAfter(column: ColumnPath): ColumnSet<C> =
+        allAfterInternal { it.path == column } as ColumnSet<C>
+
+    /** ## All (Cols) After
+     *
+     * Creates a new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] that contains a subset of columns from [this],
+     * containing all columns after [column], excluding [column] itself.
+     *
+     * [column] can be specified both relative to the current [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup] or the outer scope and
+     * can be referenced using any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi].
+     *
+     * If [column] does not exist, the function will return an empty [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * NOTE: Using the `{}` overloads of these functions requires a [ColumnSelector][org.jetbrains.kotlinx.dataframe.ColumnSelector]
+     * in the Plain DSL and on [column groups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     * On [ColumnSets][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] it requires a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter] instead.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[allAfter][ColumnsSelectionDsl.allAfter]`("someColumn") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup]`(Type::myColGroup).`[allColsAfter][SingleColumn.allColsAfter]`(someColumn) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsOf][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[Int][Int]`>().`[allAfter][ColumnSet.allAfter]`(Type::someColumn) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]` { .. }.`[allAfter][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.allAfter]`("myColumn") }`
+     *
+     * #### Flavors of All (Cols):
+     *
+     * - [`all(Cols)`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allCols]`()`:
+     *     All columns
+     *
+     * - [`all(Cols)Before`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsBefore]`(column)`:
+     *     All columns before the specified column, excluding that column
+     *
+     * - [`all(Cols)After`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsAfter]`(column)`:
+     *     All columns after the specified column, excluding that column
+     *
+     * - [`all(Cols)From`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsFrom]`(column)`:
+     *     All columns from the specified column, including that column
+     *
+     * - [`all(Cols)UpTo`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsUpTo]`(column)`:
+     *     All columns up to the specified column, including that column
+     *
+     * @return A new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns after [column], excluding [column] itself.
+     * @see [allBefore]
+     * @see [allAfter]
+     * @see [allFrom]
+     * @see [allUpTo]
+     * @see [ColumnsSelectionDsl.allExcept]
+     * @see [all]
+     * @see [cols]
+     * @param [column] The specified column after which all columns should be taken. This column can be referenced
+     *   to both relatively to the current [ColumnsResolver][org.jetbrains.kotlinx.dataframe.columns.ColumnsResolver] and absolutely.
+     */
+    public fun <C> ColumnSet<C>.allAfter(column: String): ColumnSet<C> = allAfter(pathOf(column))
+
+    /** ## All (Cols) After
+     *
+     * Creates a new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] that contains a subset of columns from [this],
+     * containing all columns after [column], excluding [column] itself.
+     *
+     * [column] can be specified both relative to the current [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup] or the outer scope and
+     * can be referenced using any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi].
+     *
+     * If [column] does not exist, the function will return an empty [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * NOTE: Using the `{}` overloads of these functions requires a [ColumnSelector][org.jetbrains.kotlinx.dataframe.ColumnSelector]
+     * in the Plain DSL and on [column groups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     * On [ColumnSets][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] it requires a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter] instead.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[allAfter][ColumnsSelectionDsl.allAfter]`("someColumn") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup]`(Type::myColGroup).`[allColsAfter][SingleColumn.allColsAfter]`(someColumn) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsOf][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[Int][Int]`>().`[allAfter][ColumnSet.allAfter]`(Type::someColumn) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]` { .. }.`[allAfter][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.allAfter]`(myColumn) }`
+     *
+     * #### Flavors of All (Cols):
+     *
+     * - [`all(Cols)`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allCols]`()`:
+     *     All columns
+     *
+     * - [`all(Cols)Before`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsBefore]`(column)`:
+     *     All columns before the specified column, excluding that column
+     *
+     * - [`all(Cols)After`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsAfter]`(column)`:
+     *     All columns after the specified column, excluding that column
+     *
+     * - [`all(Cols)From`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsFrom]`(column)`:
+     *     All columns from the specified column, including that column
+     *
+     * - [`all(Cols)UpTo`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsUpTo]`(column)`:
+     *     All columns up to the specified column, including that column
+     *
+     * @return A new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns after [column], excluding [column] itself.
+     * @see [allBefore]
+     * @see [allAfter]
+     * @see [allFrom]
+     * @see [allUpTo]
+     * @see [ColumnsSelectionDsl.allExcept]
+     * @see [all]
+     * @see [cols]
+     * @param [column] The specified column after which all columns should be taken. This column can be referenced
+     *   to both relatively to the current [ColumnsResolver][org.jetbrains.kotlinx.dataframe.columns.ColumnsResolver] and absolutely.
+     */
+    public fun <C> ColumnSet<C>.allAfter(column: AnyColumnReference): ColumnSet<C> = allAfter(column.path())
+
+    /** ## All (Cols) After
+     *
+     * Creates a new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] that contains a subset of columns from [this],
+     * containing all columns after [column], excluding [column] itself.
+     *
+     * [column] can be specified both relative to the current [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup] or the outer scope and
+     * can be referenced using any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi].
+     *
+     * If [column] does not exist, the function will return an empty [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * NOTE: Using the `{}` overloads of these functions requires a [ColumnSelector][org.jetbrains.kotlinx.dataframe.ColumnSelector]
+     * in the Plain DSL and on [column groups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     * On [ColumnSets][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] it requires a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter] instead.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[allAfter][ColumnsSelectionDsl.allAfter]`("someColumn") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup]`(Type::myColGroup).`[allColsAfter][SingleColumn.allColsAfter]`(someColumn) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsOf][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[Int][Int]`>().`[allAfter][ColumnSet.allAfter]`(Type::someColumn) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]` { .. }.`[allAfter][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.allAfter]`(Type::myColumn) }`
+     *
+     * #### Flavors of All (Cols):
+     *
+     * - [`all(Cols)`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allCols]`()`:
+     *     All columns
+     *
+     * - [`all(Cols)Before`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsBefore]`(column)`:
+     *     All columns before the specified column, excluding that column
+     *
+     * - [`all(Cols)After`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsAfter]`(column)`:
+     *     All columns after the specified column, excluding that column
+     *
+     * - [`all(Cols)From`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsFrom]`(column)`:
+     *     All columns from the specified column, including that column
+     *
+     * - [`all(Cols)UpTo`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsUpTo]`(column)`:
+     *     All columns up to the specified column, including that column
+     *
+     * @return A new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns after [column], excluding [column] itself.
+     * @see [allBefore]
+     * @see [allAfter]
+     * @see [allFrom]
+     * @see [allUpTo]
+     * @see [ColumnsSelectionDsl.allExcept]
+     * @see [all]
+     * @see [cols]
+     * @param [column] The specified column after which all columns should be taken. This column can be referenced
+     *   to both relatively to the current [ColumnsResolver][org.jetbrains.kotlinx.dataframe.columns.ColumnsResolver] and absolutely.
+     */
+    public fun <C> ColumnSet<C>.allAfter(column: KProperty<*>): ColumnSet<C> =
+        allAfter(column.toColumnAccessor().path())
+
+    /** ## All (Cols) After
+     *
+     * Creates a new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] that contains a subset of columns from [this],
+     * containing all columns after [column], excluding [column] itself.
+     *
+     * [column] can be specified both relative to the current [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup] or the outer scope and
+     * can be referenced using any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi].
+     *
+     * If [column] does not exist, the function will return an empty [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * NOTE: Using the `{}` overloads of these functions requires a [ColumnSelector][org.jetbrains.kotlinx.dataframe.ColumnSelector]
+     * in the Plain DSL and on [column groups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     * On [ColumnSets][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] it requires a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter] instead.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[allAfter][ColumnsSelectionDsl.allAfter]`("someColumn") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup]`(Type::myColGroup).`[allColsAfter][SingleColumn.allColsAfter]`(someColumn) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsOf][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[Int][Int]`>().`[allAfter][ColumnSet.allAfter]`(Type::someColumn) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[allAfter][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.allAfter]` { myColumn } }`
+     *
+     * #### Flavors of All (Cols):
+     *
+     * - [`all(Cols)`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allCols]`()`:
+     *     All columns
+     *
+     * - [`all(Cols)Before`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsBefore]`(column)`:
+     *     All columns before the specified column, excluding that column
+     *
+     * - [`all(Cols)After`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsAfter]`(column)`:
+     *     All columns after the specified column, excluding that column
+     *
+     * - [`all(Cols)From`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsFrom]`(column)`:
+     *     All columns from the specified column, including that column
+     *
+     * - [`all(Cols)UpTo`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsUpTo]`(column)`:
+     *     All columns up to the specified column, including that column
+     *
+     * @return A new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns after [column], excluding [column] itself.
+     * @see [allBefore]
+     * @see [allAfter]
+     * @see [allFrom]
+     * @see [allUpTo]
+     * @see [ColumnsSelectionDsl.allExcept]
+     * @see [all]
+     * @see [cols]
+     * @param [column] The specified column after which all columns should be taken. This column can be referenced
+     *   to both relatively to the current [ColumnsResolver][org.jetbrains.kotlinx.dataframe.columns.ColumnsResolver] and absolutely.
+     */
+    public fun <T> ColumnsSelectionDsl<T>.allAfter(column: ColumnSelector<T, *>): ColumnSet<*> =
+        asSingleColumn().allColsAfter(column)
+
+    /** ## All (Cols) After
+     *
+     * Creates a new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] that contains a subset of columns from [this],
+     * containing all columns after [column], excluding [column] itself.
+     *
+     * [column] can be specified both relative to the current [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup] or the outer scope and
+     * can be referenced using any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi].
+     *
+     * If [column] does not exist, the function will return an empty [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * NOTE: Using the `{}` overloads of these functions requires a [ColumnSelector][org.jetbrains.kotlinx.dataframe.ColumnSelector]
+     * in the Plain DSL and on [column groups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     * On [ColumnSets][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] it requires a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter] instead.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[allAfter][ColumnsSelectionDsl.allAfter]`("someColumn") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup]`(Type::myColGroup).`[allColsAfter][SingleColumn.allColsAfter]`(someColumn) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsOf][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[Int][Int]`>().`[allAfter][ColumnSet.allAfter]`(Type::someColumn) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[allAfter][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.allAfter]`("pathTo"["myColumn"]) }`
+     *
+     * #### Flavors of All (Cols):
+     *
+     * - [`all(Cols)`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allCols]`()`:
+     *     All columns
+     *
+     * - [`all(Cols)Before`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsBefore]`(column)`:
+     *     All columns before the specified column, excluding that column
+     *
+     * - [`all(Cols)After`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsAfter]`(column)`:
+     *     All columns after the specified column, excluding that column
+     *
+     * - [`all(Cols)From`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsFrom]`(column)`:
+     *     All columns from the specified column, including that column
+     *
+     * - [`all(Cols)UpTo`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsUpTo]`(column)`:
+     *     All columns up to the specified column, including that column
+     *
+     * @return A new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns after [column], excluding [column] itself.
+     * @see [allBefore]
+     * @see [allAfter]
+     * @see [allFrom]
+     * @see [allUpTo]
+     * @see [ColumnsSelectionDsl.allExcept]
+     * @see [all]
+     * @see [cols]
+     * @param [column] The specified column after which all columns should be taken. This column can be referenced
+     *   to both relatively to the current [ColumnsResolver][org.jetbrains.kotlinx.dataframe.columns.ColumnsResolver] and absolutely.
+     */
+    public fun ColumnsSelectionDsl<*>.allAfter(column: ColumnPath): ColumnSet<*> = asSingleColumn().allColsAfter(column)
+
+    /** ## All (Cols) After
+     *
+     * Creates a new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] that contains a subset of columns from [this],
+     * containing all columns after [column], excluding [column] itself.
+     *
+     * [column] can be specified both relative to the current [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup] or the outer scope and
+     * can be referenced using any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi].
+     *
+     * If [column] does not exist, the function will return an empty [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * NOTE: Using the `{}` overloads of these functions requires a [ColumnSelector][org.jetbrains.kotlinx.dataframe.ColumnSelector]
+     * in the Plain DSL and on [column groups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     * On [ColumnSets][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] it requires a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter] instead.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[allAfter][ColumnsSelectionDsl.allAfter]`("someColumn") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup]`(Type::myColGroup).`[allColsAfter][SingleColumn.allColsAfter]`(someColumn) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsOf][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[Int][Int]`>().`[allAfter][ColumnSet.allAfter]`(Type::someColumn) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[allAfter][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.allAfter]`("myColumn") }`
+     *
+     * #### Flavors of All (Cols):
+     *
+     * - [`all(Cols)`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allCols]`()`:
+     *     All columns
+     *
+     * - [`all(Cols)Before`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsBefore]`(column)`:
+     *     All columns before the specified column, excluding that column
+     *
+     * - [`all(Cols)After`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsAfter]`(column)`:
+     *     All columns after the specified column, excluding that column
+     *
+     * - [`all(Cols)From`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsFrom]`(column)`:
+     *     All columns from the specified column, including that column
+     *
+     * - [`all(Cols)UpTo`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsUpTo]`(column)`:
+     *     All columns up to the specified column, including that column
+     *
+     * @return A new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns after [column], excluding [column] itself.
+     * @see [allBefore]
+     * @see [allAfter]
+     * @see [allFrom]
+     * @see [allUpTo]
+     * @see [ColumnsSelectionDsl.allExcept]
+     * @see [all]
+     * @see [cols]
+     * @param [column] The specified column after which all columns should be taken. This column can be referenced
+     *   to both relatively to the current [ColumnsResolver][org.jetbrains.kotlinx.dataframe.columns.ColumnsResolver] and absolutely.
+     */
+    public fun ColumnsSelectionDsl<*>.allAfter(column: String): ColumnSet<*> = allAfter(pathOf(column))
+
+    /** ## All (Cols) After
+     *
+     * Creates a new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] that contains a subset of columns from [this],
+     * containing all columns after [column], excluding [column] itself.
+     *
+     * [column] can be specified both relative to the current [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup] or the outer scope and
+     * can be referenced using any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi].
+     *
+     * If [column] does not exist, the function will return an empty [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * NOTE: Using the `{}` overloads of these functions requires a [ColumnSelector][org.jetbrains.kotlinx.dataframe.ColumnSelector]
+     * in the Plain DSL and on [column groups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     * On [ColumnSets][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] it requires a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter] instead.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[allAfter][ColumnsSelectionDsl.allAfter]`("someColumn") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup]`(Type::myColGroup).`[allColsAfter][SingleColumn.allColsAfter]`(someColumn) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsOf][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[Int][Int]`>().`[allAfter][ColumnSet.allAfter]`(Type::someColumn) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[allAfter][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.allAfter]`(myColumn) }`
+     *
+     * #### Flavors of All (Cols):
+     *
+     * - [`all(Cols)`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allCols]`()`:
+     *     All columns
+     *
+     * - [`all(Cols)Before`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsBefore]`(column)`:
+     *     All columns before the specified column, excluding that column
+     *
+     * - [`all(Cols)After`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsAfter]`(column)`:
+     *     All columns after the specified column, excluding that column
+     *
+     * - [`all(Cols)From`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsFrom]`(column)`:
+     *     All columns from the specified column, including that column
+     *
+     * - [`all(Cols)UpTo`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsUpTo]`(column)`:
+     *     All columns up to the specified column, including that column
+     *
+     * @return A new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns after [column], excluding [column] itself.
+     * @see [allBefore]
+     * @see [allAfter]
+     * @see [allFrom]
+     * @see [allUpTo]
+     * @see [ColumnsSelectionDsl.allExcept]
+     * @see [all]
+     * @see [cols]
+     * @param [column] The specified column after which all columns should be taken. This column can be referenced
+     *   to both relatively to the current [ColumnsResolver][org.jetbrains.kotlinx.dataframe.columns.ColumnsResolver] and absolutely.
+     */
+    public fun ColumnsSelectionDsl<*>.allAfter(column: AnyColumnReference): ColumnSet<*> = allAfter(column.path())
+
+    /** ## All (Cols) After
+     *
+     * Creates a new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] that contains a subset of columns from [this],
+     * containing all columns after [column], excluding [column] itself.
+     *
+     * [column] can be specified both relative to the current [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup] or the outer scope and
+     * can be referenced using any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi].
+     *
+     * If [column] does not exist, the function will return an empty [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * NOTE: Using the `{}` overloads of these functions requires a [ColumnSelector][org.jetbrains.kotlinx.dataframe.ColumnSelector]
+     * in the Plain DSL and on [column groups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     * On [ColumnSets][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] it requires a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter] instead.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[allAfter][ColumnsSelectionDsl.allAfter]`("someColumn") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup]`(Type::myColGroup).`[allColsAfter][SingleColumn.allColsAfter]`(someColumn) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsOf][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[Int][Int]`>().`[allAfter][ColumnSet.allAfter]`(Type::someColumn) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[allAfter][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.allAfter]`(Type::myColumn) }`
+     *
+     * #### Flavors of All (Cols):
+     *
+     * - [`all(Cols)`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allCols]`()`:
+     *     All columns
+     *
+     * - [`all(Cols)Before`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsBefore]`(column)`:
+     *     All columns before the specified column, excluding that column
+     *
+     * - [`all(Cols)After`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsAfter]`(column)`:
+     *     All columns after the specified column, excluding that column
+     *
+     * - [`all(Cols)From`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsFrom]`(column)`:
+     *     All columns from the specified column, including that column
+     *
+     * - [`all(Cols)UpTo`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsUpTo]`(column)`:
+     *     All columns up to the specified column, including that column
+     *
+     * @return A new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns after [column], excluding [column] itself.
+     * @see [allBefore]
+     * @see [allAfter]
+     * @see [allFrom]
+     * @see [allUpTo]
+     * @see [ColumnsSelectionDsl.allExcept]
+     * @see [all]
+     * @see [cols]
+     * @param [column] The specified column after which all columns should be taken. This column can be referenced
+     *   to both relatively to the current [ColumnsResolver][org.jetbrains.kotlinx.dataframe.columns.ColumnsResolver] and absolutely.
+     */
+    public fun ColumnsSelectionDsl<*>.allAfter(column: KProperty<*>): ColumnSet<*> =
+        allAfter(column.toColumnAccessor().path())
+
+    /** ## All (Cols) After
+     *
+     * Creates a new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] that contains a subset of columns from [this],
+     * containing all columns after [column], excluding [column] itself.
+     *
+     * [column] can be specified both relative to the current [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup] or the outer scope and
+     * can be referenced using any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi].
+     *
+     * If [column] does not exist, the function will return an empty [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * NOTE: Using the `{}` overloads of these functions requires a [ColumnSelector][org.jetbrains.kotlinx.dataframe.ColumnSelector]
+     * in the Plain DSL and on [column groups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     * On [ColumnSets][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] it requires a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter] instead.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[allAfter][ColumnsSelectionDsl.allAfter]`("someColumn") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup]`(Type::myColGroup).`[allColsAfter][SingleColumn.allColsAfter]`(someColumn) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsOf][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[Int][Int]`>().`[allAfter][ColumnSet.allAfter]`(Type::someColumn) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { someColumnGroup.`[allColsAfter][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.allColsAfter]` { myColumn } }`
+     *
+     * #### Flavors of All (Cols):
+     *
+     * - [`all(Cols)`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allCols]`()`:
+     *     All columns
+     *
+     * - [`all(Cols)Before`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsBefore]`(column)`:
+     *     All columns before the specified column, excluding that column
+     *
+     * - [`all(Cols)After`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsAfter]`(column)`:
+     *     All columns after the specified column, excluding that column
+     *
+     * - [`all(Cols)From`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsFrom]`(column)`:
+     *     All columns from the specified column, including that column
+     *
+     * - [`all(Cols)UpTo`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsUpTo]`(column)`:
+     *     All columns up to the specified column, including that column
+     *
+     * @return A new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns after [column], excluding [column] itself.
+     * @see [allBefore]
+     * @see [allAfter]
+     * @see [allFrom]
+     * @see [allUpTo]
+     * @see [ColumnsSelectionDsl.allExcept]
+     * @see [all]
+     * @see [cols]
+     * @param [column] The specified column after which all columns should be taken. This column can be referenced
+     *   to both relatively to the current [ColumnsResolver][org.jetbrains.kotlinx.dataframe.columns.ColumnsResolver] and absolutely.
+     */
+    public fun <T> SingleColumn<DataRow<T>>.allColsAfter(column: ColumnSelector<T, *>): ColumnSet<*> {
+        var resolvedCol: DataColumn<*>? = null
+        return this
+            .ensureIsColumnGroup()
+            .onResolve { resolvedCol = it!!.asColumnGroup().getColumn(column) }
+            .allAfterInternal { it.data == resolvedCol!! }
+    }
+
+    /** ## All (Cols) After
+     *
+     * Creates a new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] that contains a subset of columns from [this],
+     * containing all columns after [column], excluding [column] itself.
+     *
+     * [column] can be specified both relative to the current [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup] or the outer scope and
+     * can be referenced using any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi].
+     *
+     * If [column] does not exist, the function will return an empty [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * NOTE: Using the `{}` overloads of these functions requires a [ColumnSelector][org.jetbrains.kotlinx.dataframe.ColumnSelector]
+     * in the Plain DSL and on [column groups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     * On [ColumnSets][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] it requires a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter] instead.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[allAfter][ColumnsSelectionDsl.allAfter]`("someColumn") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup]`(Type::myColGroup).`[allColsAfter][SingleColumn.allColsAfter]`(someColumn) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsOf][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[Int][Int]`>().`[allAfter][ColumnSet.allAfter]`(Type::someColumn) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { someColumnGroup.`[allColsAfter][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.allColsAfter]`("pathTo"["myColumn"]) }`
+     *
+     * #### Flavors of All (Cols):
+     *
+     * - [`all(Cols)`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allCols]`()`:
+     *     All columns
+     *
+     * - [`all(Cols)Before`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsBefore]`(column)`:
+     *     All columns before the specified column, excluding that column
+     *
+     * - [`all(Cols)After`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsAfter]`(column)`:
+     *     All columns after the specified column, excluding that column
+     *
+     * - [`all(Cols)From`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsFrom]`(column)`:
+     *     All columns from the specified column, including that column
+     *
+     * - [`all(Cols)UpTo`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsUpTo]`(column)`:
+     *     All columns up to the specified column, including that column
+     *
+     * @return A new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns after [column], excluding [column] itself.
+     * @see [allBefore]
+     * @see [allAfter]
+     * @see [allFrom]
+     * @see [allUpTo]
+     * @see [ColumnsSelectionDsl.allExcept]
+     * @see [all]
+     * @see [cols]
+     * @param [column] The specified column after which all columns should be taken. This column can be referenced
+     *   to both relatively to the current [ColumnsResolver][org.jetbrains.kotlinx.dataframe.columns.ColumnsResolver] and absolutely.
+     */
+    public fun SingleColumn<DataRow<*>>.allColsAfter(column: ColumnPath): ColumnSet<*> {
+        var path: ColumnPath? = null
+        return this
+            .ensureIsColumnGroup()
+            .onResolve { path = it!!.path }
+            .allAfterInternal {
+                // accept both relative and full column path
+                it.path == path!! + column || it.path == column
+            }
+    }
+
+    /** ## All (Cols) After
+     *
+     * Creates a new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] that contains a subset of columns from [this],
+     * containing all columns after [column], excluding [column] itself.
+     *
+     * [column] can be specified both relative to the current [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup] or the outer scope and
+     * can be referenced using any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi].
+     *
+     * If [column] does not exist, the function will return an empty [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * NOTE: Using the `{}` overloads of these functions requires a [ColumnSelector][org.jetbrains.kotlinx.dataframe.ColumnSelector]
+     * in the Plain DSL and on [column groups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     * On [ColumnSets][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] it requires a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter] instead.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[allAfter][ColumnsSelectionDsl.allAfter]`("someColumn") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup]`(Type::myColGroup).`[allColsAfter][SingleColumn.allColsAfter]`(someColumn) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsOf][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[Int][Int]`>().`[allAfter][ColumnSet.allAfter]`(Type::someColumn) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { someColumnGroup.`[allColsAfter][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.allColsAfter]`("myColumn") }`
+     *
+     * #### Flavors of All (Cols):
+     *
+     * - [`all(Cols)`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allCols]`()`:
+     *     All columns
+     *
+     * - [`all(Cols)Before`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsBefore]`(column)`:
+     *     All columns before the specified column, excluding that column
+     *
+     * - [`all(Cols)After`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsAfter]`(column)`:
+     *     All columns after the specified column, excluding that column
+     *
+     * - [`all(Cols)From`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsFrom]`(column)`:
+     *     All columns from the specified column, including that column
+     *
+     * - [`all(Cols)UpTo`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsUpTo]`(column)`:
+     *     All columns up to the specified column, including that column
+     *
+     * @return A new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns after [column], excluding [column] itself.
+     * @see [allBefore]
+     * @see [allAfter]
+     * @see [allFrom]
+     * @see [allUpTo]
+     * @see [ColumnsSelectionDsl.allExcept]
+     * @see [all]
+     * @see [cols]
+     * @param [column] The specified column after which all columns should be taken. This column can be referenced
+     *   to both relatively to the current [ColumnsResolver][org.jetbrains.kotlinx.dataframe.columns.ColumnsResolver] and absolutely.
+     */
+    public fun SingleColumn<DataRow<*>>.allColsAfter(column: String): ColumnSet<*> = allColsAfter(pathOf(column))
+
+    /** ## All (Cols) After
+     *
+     * Creates a new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] that contains a subset of columns from [this],
+     * containing all columns after [column], excluding [column] itself.
+     *
+     * [column] can be specified both relative to the current [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup] or the outer scope and
+     * can be referenced using any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi].
+     *
+     * If [column] does not exist, the function will return an empty [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * NOTE: Using the `{}` overloads of these functions requires a [ColumnSelector][org.jetbrains.kotlinx.dataframe.ColumnSelector]
+     * in the Plain DSL and on [column groups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     * On [ColumnSets][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] it requires a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter] instead.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[allAfter][ColumnsSelectionDsl.allAfter]`("someColumn") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup]`(Type::myColGroup).`[allColsAfter][SingleColumn.allColsAfter]`(someColumn) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsOf][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[Int][Int]`>().`[allAfter][ColumnSet.allAfter]`(Type::someColumn) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { someColumnGroup.`[allColsAfter][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.allColsAfter]`(myColumn) }`
+     *
+     * #### Flavors of All (Cols):
+     *
+     * - [`all(Cols)`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allCols]`()`:
+     *     All columns
+     *
+     * - [`all(Cols)Before`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsBefore]`(column)`:
+     *     All columns before the specified column, excluding that column
+     *
+     * - [`all(Cols)After`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsAfter]`(column)`:
+     *     All columns after the specified column, excluding that column
+     *
+     * - [`all(Cols)From`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsFrom]`(column)`:
+     *     All columns from the specified column, including that column
+     *
+     * - [`all(Cols)UpTo`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsUpTo]`(column)`:
+     *     All columns up to the specified column, including that column
+     *
+     * @return A new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns after [column], excluding [column] itself.
+     * @see [allBefore]
+     * @see [allAfter]
+     * @see [allFrom]
+     * @see [allUpTo]
+     * @see [ColumnsSelectionDsl.allExcept]
+     * @see [all]
+     * @see [cols]
+     * @param [column] The specified column after which all columns should be taken. This column can be referenced
+     *   to both relatively to the current [ColumnsResolver][org.jetbrains.kotlinx.dataframe.columns.ColumnsResolver] and absolutely.
+     */
+    public fun SingleColumn<DataRow<*>>.allColsAfter(column: AnyColumnReference): ColumnSet<*> =
+        allColsAfter(column.path())
+
+    /** ## All (Cols) After
+     *
+     * Creates a new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] that contains a subset of columns from [this],
+     * containing all columns after [column], excluding [column] itself.
+     *
+     * [column] can be specified both relative to the current [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup] or the outer scope and
+     * can be referenced using any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi].
+     *
+     * If [column] does not exist, the function will return an empty [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * NOTE: Using the `{}` overloads of these functions requires a [ColumnSelector][org.jetbrains.kotlinx.dataframe.ColumnSelector]
+     * in the Plain DSL and on [column groups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     * On [ColumnSets][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] it requires a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter] instead.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[allAfter][ColumnsSelectionDsl.allAfter]`("someColumn") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup]`(Type::myColGroup).`[allColsAfter][SingleColumn.allColsAfter]`(someColumn) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsOf][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[Int][Int]`>().`[allAfter][ColumnSet.allAfter]`(Type::someColumn) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { someColumnGroup.`[allColsAfter][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.allColsAfter]`(Type::myColumn) }`
+     *
+     * #### Flavors of All (Cols):
+     *
+     * - [`all(Cols)`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allCols]`()`:
+     *     All columns
+     *
+     * - [`all(Cols)Before`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsBefore]`(column)`:
+     *     All columns before the specified column, excluding that column
+     *
+     * - [`all(Cols)After`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsAfter]`(column)`:
+     *     All columns after the specified column, excluding that column
+     *
+     * - [`all(Cols)From`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsFrom]`(column)`:
+     *     All columns from the specified column, including that column
+     *
+     * - [`all(Cols)UpTo`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsUpTo]`(column)`:
+     *     All columns up to the specified column, including that column
+     *
+     * @return A new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns after [column], excluding [column] itself.
+     * @see [allBefore]
+     * @see [allAfter]
+     * @see [allFrom]
+     * @see [allUpTo]
+     * @see [ColumnsSelectionDsl.allExcept]
+     * @see [all]
+     * @see [cols]
+     * @param [column] The specified column after which all columns should be taken. This column can be referenced
+     *   to both relatively to the current [ColumnsResolver][org.jetbrains.kotlinx.dataframe.columns.ColumnsResolver] and absolutely.
+     */
+    public fun SingleColumn<DataRow<*>>.allColsAfter(column: KProperty<*>): ColumnSet<*> =
+        allColsAfter(column.toColumnAccessor().path())
+
+    /** ## All (Cols) After
+     *
+     * Creates a new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] that contains a subset of columns from [this],
+     * containing all columns after [column], excluding [column] itself.
+     *
+     * [column] can be specified both relative to the current [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup] or the outer scope and
+     * can be referenced using any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi].
+     *
+     * If [column] does not exist, the function will return an empty [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * NOTE: Using the `{}` overloads of these functions requires a [ColumnSelector][org.jetbrains.kotlinx.dataframe.ColumnSelector]
+     * in the Plain DSL and on [column groups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     * On [ColumnSets][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] it requires a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter] instead.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[allAfter][ColumnsSelectionDsl.allAfter]`("someColumn") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup]`(Type::myColGroup).`[allColsAfter][SingleColumn.allColsAfter]`(someColumn) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsOf][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[Int][Int]`>().`[allAfter][ColumnSet.allAfter]`(Type::someColumn) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "someColGroup".`[allColsAfter][kotlin.String.allColsAfter]` { myColumn } }`
+     *
+     * #### Flavors of All (Cols):
+     *
+     * - [`all(Cols)`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allCols]`()`:
+     *     All columns
+     *
+     * - [`all(Cols)Before`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsBefore]`(column)`:
+     *     All columns before the specified column, excluding that column
+     *
+     * - [`all(Cols)After`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsAfter]`(column)`:
+     *     All columns after the specified column, excluding that column
+     *
+     * - [`all(Cols)From`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsFrom]`(column)`:
+     *     All columns from the specified column, including that column
+     *
+     * - [`all(Cols)UpTo`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsUpTo]`(column)`:
+     *     All columns up to the specified column, including that column
+     *
+     * @return A new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns after [column], excluding [column] itself.
+     * @see [allBefore]
+     * @see [allAfter]
+     * @see [allFrom]
+     * @see [allUpTo]
+     * @see [ColumnsSelectionDsl.allExcept]
+     * @see [all]
+     * @see [cols]
+     * @param [column] The specified column after which all columns should be taken. This column can be referenced
+     *   to both relatively to the current [ColumnsResolver][org.jetbrains.kotlinx.dataframe.columns.ColumnsResolver] and absolutely.
+     */
+    public fun String.allColsAfter(column: ColumnSelector<*, *>): ColumnSet<*> = columnGroup(this).allColsAfter(column)
+
+    /** ## All (Cols) After
+     *
+     * Creates a new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] that contains a subset of columns from [this],
+     * containing all columns after [column], excluding [column] itself.
+     *
+     * [column] can be specified both relative to the current [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup] or the outer scope and
+     * can be referenced using any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi].
+     *
+     * If [column] does not exist, the function will return an empty [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * NOTE: Using the `{}` overloads of these functions requires a [ColumnSelector][org.jetbrains.kotlinx.dataframe.ColumnSelector]
+     * in the Plain DSL and on [column groups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     * On [ColumnSets][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] it requires a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter] instead.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[allAfter][ColumnsSelectionDsl.allAfter]`("someColumn") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup]`(Type::myColGroup).`[allColsAfter][SingleColumn.allColsAfter]`(someColumn) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsOf][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[Int][Int]`>().`[allAfter][ColumnSet.allAfter]`(Type::someColumn) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "someColGroup".`[allColsAfter][kotlin.String.allColsAfter]`("pathTo"["myColumn"]) }`
+     *
+     * #### Flavors of All (Cols):
+     *
+     * - [`all(Cols)`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allCols]`()`:
+     *     All columns
+     *
+     * - [`all(Cols)Before`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsBefore]`(column)`:
+     *     All columns before the specified column, excluding that column
+     *
+     * - [`all(Cols)After`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsAfter]`(column)`:
+     *     All columns after the specified column, excluding that column
+     *
+     * - [`all(Cols)From`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsFrom]`(column)`:
+     *     All columns from the specified column, including that column
+     *
+     * - [`all(Cols)UpTo`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsUpTo]`(column)`:
+     *     All columns up to the specified column, including that column
+     *
+     * @return A new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns after [column], excluding [column] itself.
+     * @see [allBefore]
+     * @see [allAfter]
+     * @see [allFrom]
+     * @see [allUpTo]
+     * @see [ColumnsSelectionDsl.allExcept]
+     * @see [all]
+     * @see [cols]
+     * @param [column] The specified column after which all columns should be taken. This column can be referenced
+     *   to both relatively to the current [ColumnsResolver][org.jetbrains.kotlinx.dataframe.columns.ColumnsResolver] and absolutely.
+     */
+    public fun String.allColsAfter(column: ColumnPath): ColumnSet<*> = columnGroup(this).allColsAfter(column)
+
+    /** ## All (Cols) After
+     *
+     * Creates a new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] that contains a subset of columns from [this],
+     * containing all columns after [column], excluding [column] itself.
+     *
+     * [column] can be specified both relative to the current [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup] or the outer scope and
+     * can be referenced using any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi].
+     *
+     * If [column] does not exist, the function will return an empty [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * NOTE: Using the `{}` overloads of these functions requires a [ColumnSelector][org.jetbrains.kotlinx.dataframe.ColumnSelector]
+     * in the Plain DSL and on [column groups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     * On [ColumnSets][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] it requires a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter] instead.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[allAfter][ColumnsSelectionDsl.allAfter]`("someColumn") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup]`(Type::myColGroup).`[allColsAfter][SingleColumn.allColsAfter]`(someColumn) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsOf][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[Int][Int]`>().`[allAfter][ColumnSet.allAfter]`(Type::someColumn) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "someColGroup".`[allColsAfter][kotlin.String.allColsAfter]`("myColumn") }`
+     *
+     * #### Flavors of All (Cols):
+     *
+     * - [`all(Cols)`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allCols]`()`:
+     *     All columns
+     *
+     * - [`all(Cols)Before`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsBefore]`(column)`:
+     *     All columns before the specified column, excluding that column
+     *
+     * - [`all(Cols)After`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsAfter]`(column)`:
+     *     All columns after the specified column, excluding that column
+     *
+     * - [`all(Cols)From`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsFrom]`(column)`:
+     *     All columns from the specified column, including that column
+     *
+     * - [`all(Cols)UpTo`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsUpTo]`(column)`:
+     *     All columns up to the specified column, including that column
+     *
+     * @return A new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns after [column], excluding [column] itself.
+     * @see [allBefore]
+     * @see [allAfter]
+     * @see [allFrom]
+     * @see [allUpTo]
+     * @see [ColumnsSelectionDsl.allExcept]
+     * @see [all]
+     * @see [cols]
+     * @param [column] The specified column after which all columns should be taken. This column can be referenced
+     *   to both relatively to the current [ColumnsResolver][org.jetbrains.kotlinx.dataframe.columns.ColumnsResolver] and absolutely.
+     */
+    public fun String.allColsAfter(column: String): ColumnSet<*> = columnGroup(this).allColsAfter(column)
+
+    /** ## All (Cols) After
+     *
+     * Creates a new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] that contains a subset of columns from [this],
+     * containing all columns after [column], excluding [column] itself.
+     *
+     * [column] can be specified both relative to the current [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup] or the outer scope and
+     * can be referenced using any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi].
+     *
+     * If [column] does not exist, the function will return an empty [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * NOTE: Using the `{}` overloads of these functions requires a [ColumnSelector][org.jetbrains.kotlinx.dataframe.ColumnSelector]
+     * in the Plain DSL and on [column groups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     * On [ColumnSets][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] it requires a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter] instead.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[allAfter][ColumnsSelectionDsl.allAfter]`("someColumn") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup]`(Type::myColGroup).`[allColsAfter][SingleColumn.allColsAfter]`(someColumn) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsOf][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[Int][Int]`>().`[allAfter][ColumnSet.allAfter]`(Type::someColumn) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "someColGroup".`[allColsAfter][kotlin.String.allColsAfter]`(myColumn) }`
+     *
+     * #### Flavors of All (Cols):
+     *
+     * - [`all(Cols)`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allCols]`()`:
+     *     All columns
+     *
+     * - [`all(Cols)Before`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsBefore]`(column)`:
+     *     All columns before the specified column, excluding that column
+     *
+     * - [`all(Cols)After`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsAfter]`(column)`:
+     *     All columns after the specified column, excluding that column
+     *
+     * - [`all(Cols)From`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsFrom]`(column)`:
+     *     All columns from the specified column, including that column
+     *
+     * - [`all(Cols)UpTo`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsUpTo]`(column)`:
+     *     All columns up to the specified column, including that column
+     *
+     * @return A new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns after [column], excluding [column] itself.
+     * @see [allBefore]
+     * @see [allAfter]
+     * @see [allFrom]
+     * @see [allUpTo]
+     * @see [ColumnsSelectionDsl.allExcept]
+     * @see [all]
+     * @see [cols]
+     * @param [column] The specified column after which all columns should be taken. This column can be referenced
+     *   to both relatively to the current [ColumnsResolver][org.jetbrains.kotlinx.dataframe.columns.ColumnsResolver] and absolutely.
+     */
+    public fun String.allColsAfter(column: AnyColumnReference): ColumnSet<*> = columnGroup(this).allColsAfter(column)
+
+    /** ## All (Cols) After
+     *
+     * Creates a new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] that contains a subset of columns from [this],
+     * containing all columns after [column], excluding [column] itself.
+     *
+     * [column] can be specified both relative to the current [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup] or the outer scope and
+     * can be referenced using any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi].
+     *
+     * If [column] does not exist, the function will return an empty [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * NOTE: Using the `{}` overloads of these functions requires a [ColumnSelector][org.jetbrains.kotlinx.dataframe.ColumnSelector]
+     * in the Plain DSL and on [column groups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     * On [ColumnSets][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] it requires a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter] instead.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[allAfter][ColumnsSelectionDsl.allAfter]`("someColumn") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup]`(Type::myColGroup).`[allColsAfter][SingleColumn.allColsAfter]`(someColumn) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsOf][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[Int][Int]`>().`[allAfter][ColumnSet.allAfter]`(Type::someColumn) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "someColGroup".`[allColsAfter][kotlin.String.allColsAfter]`(Type::myColumn) }`
+     *
+     * #### Flavors of All (Cols):
+     *
+     * - [`all(Cols)`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allCols]`()`:
+     *     All columns
+     *
+     * - [`all(Cols)Before`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsBefore]`(column)`:
+     *     All columns before the specified column, excluding that column
+     *
+     * - [`all(Cols)After`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsAfter]`(column)`:
+     *     All columns after the specified column, excluding that column
+     *
+     * - [`all(Cols)From`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsFrom]`(column)`:
+     *     All columns from the specified column, including that column
+     *
+     * - [`all(Cols)UpTo`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsUpTo]`(column)`:
+     *     All columns up to the specified column, including that column
+     *
+     * @return A new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns after [column], excluding [column] itself.
+     * @see [allBefore]
+     * @see [allAfter]
+     * @see [allFrom]
+     * @see [allUpTo]
+     * @see [ColumnsSelectionDsl.allExcept]
+     * @see [all]
+     * @see [cols]
+     * @param [column] The specified column after which all columns should be taken. This column can be referenced
+     *   to both relatively to the current [ColumnsResolver][org.jetbrains.kotlinx.dataframe.columns.ColumnsResolver] and absolutely.
+     */
+    public fun String.allColsAfter(column: KProperty<*>): ColumnSet<*> = columnGroup(this).allColsAfter(column)
+
+    /**
+     * ## All (Cols) After
+     *
+     * Creates a new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] that contains a subset of columns from [this],
+     * containing all columns after [column], excluding [column] itself.
+     *
+     * [column] can be specified both relative to the current [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup] or the outer scope and
+     * can be referenced using any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi].
+     *
+     * If [column] does not exist, the function will return an empty [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * NOTE: Using the `{}` overloads of these functions requires a [ColumnSelector][org.jetbrains.kotlinx.dataframe.ColumnSelector]
+     * in the Plain DSL and on [column groups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     * On [ColumnSets][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] it requires a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter] instead.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[allAfter][ColumnsSelectionDsl.allAfter]`("someColumn") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup]`(Type::myColGroup).`[allColsAfter][SingleColumn.allColsAfter]`(someColumn) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsOf][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[Int][Int]`>().`[allAfter][ColumnSet.allAfter]`(Type::someColumn) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { DataSchemaType::myColGroup.`[allColsAfter][kotlin.reflect.KProperty.allColsAfter]` { myColumn } }`
+     *
+     * #### Flavors of All (Cols):
+     *
+     * - [`all(Cols)`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allCols]`()`:
+     *     All columns
+     *
+     * - [`all(Cols)Before`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsBefore]`(column)`:
+     *     All columns before the specified column, excluding that column
+     *
+     * - [`all(Cols)After`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsAfter]`(column)`:
+     *     All columns after the specified column, excluding that column
+     *
+     * - [`all(Cols)From`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsFrom]`(column)`:
+     *     All columns from the specified column, including that column
+     *
+     * - [`all(Cols)UpTo`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsUpTo]`(column)`:
+     *     All columns up to the specified column, including that column
+     *
+     * @return A new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns after [column], excluding [column] itself.
+     * @see [allBefore]
+     * @see [allAfter]
+     * @see [allFrom]
+     * @see [allUpTo]
+     * @see [ColumnsSelectionDsl.allExcept]
+     * @see [all]
+     * @see [cols]
+     * @param [column] The specified column after which all columns should be taken. This column can be referenced
+     *   to both relatively to the current [ColumnsResolver][org.jetbrains.kotlinx.dataframe.columns.ColumnsResolver] and absolutely.
+     */
+    public fun <C> KProperty<C>.allColsAfter(column: ColumnSelector<C, *>): ColumnSet<*> =
+        columnGroup(this).allColsAfter(column)
+
+    /** ## All (Cols) After
+     *
+     * Creates a new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] that contains a subset of columns from [this],
+     * containing all columns after [column], excluding [column] itself.
+     *
+     * [column] can be specified both relative to the current [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup] or the outer scope and
+     * can be referenced using any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi].
+     *
+     * If [column] does not exist, the function will return an empty [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * NOTE: Using the `{}` overloads of these functions requires a [ColumnSelector][org.jetbrains.kotlinx.dataframe.ColumnSelector]
+     * in the Plain DSL and on [column groups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     * On [ColumnSets][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] it requires a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter] instead.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[allAfter][ColumnsSelectionDsl.allAfter]`("someColumn") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup]`(Type::myColGroup).`[allColsAfter][SingleColumn.allColsAfter]`(someColumn) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsOf][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[Int][Int]`>().`[allAfter][ColumnSet.allAfter]`(Type::someColumn) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { DataSchemaType::myColGroup.`[allColsAfter][kotlin.reflect.KProperty.allColsAfter]`("pathTo"["myColumn"]) }`
+     *
+     * #### Flavors of All (Cols):
+     *
+     * - [`all(Cols)`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allCols]`()`:
+     *     All columns
+     *
+     * - [`all(Cols)Before`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsBefore]`(column)`:
+     *     All columns before the specified column, excluding that column
+     *
+     * - [`all(Cols)After`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsAfter]`(column)`:
+     *     All columns after the specified column, excluding that column
+     *
+     * - [`all(Cols)From`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsFrom]`(column)`:
+     *     All columns from the specified column, including that column
+     *
+     * - [`all(Cols)UpTo`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsUpTo]`(column)`:
+     *     All columns up to the specified column, including that column
+     *
+     * @return A new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns after [column], excluding [column] itself.
+     * @see [allBefore]
+     * @see [allAfter]
+     * @see [allFrom]
+     * @see [allUpTo]
+     * @see [ColumnsSelectionDsl.allExcept]
+     * @see [all]
+     * @see [cols]
+     * @param [column] The specified column after which all columns should be taken. This column can be referenced
+     *   to both relatively to the current [ColumnsResolver][org.jetbrains.kotlinx.dataframe.columns.ColumnsResolver] and absolutely.
+     */
+    public fun KProperty<*>.allColsAfter(column: ColumnPath): ColumnSet<*> = columnGroup(this).allColsAfter(column)
+
+    /** ## All (Cols) After
+     *
+     * Creates a new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] that contains a subset of columns from [this],
+     * containing all columns after [column], excluding [column] itself.
+     *
+     * [column] can be specified both relative to the current [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup] or the outer scope and
+     * can be referenced using any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi].
+     *
+     * If [column] does not exist, the function will return an empty [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * NOTE: Using the `{}` overloads of these functions requires a [ColumnSelector][org.jetbrains.kotlinx.dataframe.ColumnSelector]
+     * in the Plain DSL and on [column groups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     * On [ColumnSets][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] it requires a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter] instead.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[allAfter][ColumnsSelectionDsl.allAfter]`("someColumn") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup]`(Type::myColGroup).`[allColsAfter][SingleColumn.allColsAfter]`(someColumn) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsOf][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[Int][Int]`>().`[allAfter][ColumnSet.allAfter]`(Type::someColumn) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { DataSchemaType::myColGroup.`[allColsAfter][kotlin.reflect.KProperty.allColsAfter]`("myColumn") }`
+     *
+     * #### Flavors of All (Cols):
+     *
+     * - [`all(Cols)`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allCols]`()`:
+     *     All columns
+     *
+     * - [`all(Cols)Before`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsBefore]`(column)`:
+     *     All columns before the specified column, excluding that column
+     *
+     * - [`all(Cols)After`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsAfter]`(column)`:
+     *     All columns after the specified column, excluding that column
+     *
+     * - [`all(Cols)From`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsFrom]`(column)`:
+     *     All columns from the specified column, including that column
+     *
+     * - [`all(Cols)UpTo`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsUpTo]`(column)`:
+     *     All columns up to the specified column, including that column
+     *
+     * @return A new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns after [column], excluding [column] itself.
+     * @see [allBefore]
+     * @see [allAfter]
+     * @see [allFrom]
+     * @see [allUpTo]
+     * @see [ColumnsSelectionDsl.allExcept]
+     * @see [all]
+     * @see [cols]
+     * @param [column] The specified column after which all columns should be taken. This column can be referenced
+     *   to both relatively to the current [ColumnsResolver][org.jetbrains.kotlinx.dataframe.columns.ColumnsResolver] and absolutely.
+     */
+    public fun KProperty<*>.allColsAfter(column: String): ColumnSet<*> = columnGroup(this).allColsAfter(column)
+
+    /** ## All (Cols) After
+     *
+     * Creates a new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] that contains a subset of columns from [this],
+     * containing all columns after [column], excluding [column] itself.
+     *
+     * [column] can be specified both relative to the current [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup] or the outer scope and
+     * can be referenced using any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi].
+     *
+     * If [column] does not exist, the function will return an empty [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * NOTE: Using the `{}` overloads of these functions requires a [ColumnSelector][org.jetbrains.kotlinx.dataframe.ColumnSelector]
+     * in the Plain DSL and on [column groups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     * On [ColumnSets][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] it requires a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter] instead.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[allAfter][ColumnsSelectionDsl.allAfter]`("someColumn") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup]`(Type::myColGroup).`[allColsAfter][SingleColumn.allColsAfter]`(someColumn) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsOf][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[Int][Int]`>().`[allAfter][ColumnSet.allAfter]`(Type::someColumn) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { DataSchemaType::myColGroup.`[allColsAfter][kotlin.reflect.KProperty.allColsAfter]`(myColumn) }`
+     *
+     * #### Flavors of All (Cols):
+     *
+     * - [`all(Cols)`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allCols]`()`:
+     *     All columns
+     *
+     * - [`all(Cols)Before`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsBefore]`(column)`:
+     *     All columns before the specified column, excluding that column
+     *
+     * - [`all(Cols)After`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsAfter]`(column)`:
+     *     All columns after the specified column, excluding that column
+     *
+     * - [`all(Cols)From`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsFrom]`(column)`:
+     *     All columns from the specified column, including that column
+     *
+     * - [`all(Cols)UpTo`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsUpTo]`(column)`:
+     *     All columns up to the specified column, including that column
+     *
+     * @return A new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns after [column], excluding [column] itself.
+     * @see [allBefore]
+     * @see [allAfter]
+     * @see [allFrom]
+     * @see [allUpTo]
+     * @see [ColumnsSelectionDsl.allExcept]
+     * @see [all]
+     * @see [cols]
+     * @param [column] The specified column after which all columns should be taken. This column can be referenced
+     *   to both relatively to the current [ColumnsResolver][org.jetbrains.kotlinx.dataframe.columns.ColumnsResolver] and absolutely.
+     */
+    public fun KProperty<*>.allColsAfter(column: AnyColumnReference): ColumnSet<*> =
+        columnGroup(this).allColsAfter(column)
+
+    /** ## All (Cols) After
+     *
+     * Creates a new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] that contains a subset of columns from [this],
+     * containing all columns after [column], excluding [column] itself.
+     *
+     * [column] can be specified both relative to the current [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup] or the outer scope and
+     * can be referenced using any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi].
+     *
+     * If [column] does not exist, the function will return an empty [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * NOTE: Using the `{}` overloads of these functions requires a [ColumnSelector][org.jetbrains.kotlinx.dataframe.ColumnSelector]
+     * in the Plain DSL and on [column groups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     * On [ColumnSets][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] it requires a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter] instead.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[allAfter][ColumnsSelectionDsl.allAfter]`("someColumn") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup]`(Type::myColGroup).`[allColsAfter][SingleColumn.allColsAfter]`(someColumn) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsOf][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[Int][Int]`>().`[allAfter][ColumnSet.allAfter]`(Type::someColumn) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { DataSchemaType::myColGroup.`[allColsAfter][kotlin.reflect.KProperty.allColsAfter]`(Type::myColumn) }`
+     *
+     * #### Flavors of All (Cols):
+     *
+     * - [`all(Cols)`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allCols]`()`:
+     *     All columns
+     *
+     * - [`all(Cols)Before`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsBefore]`(column)`:
+     *     All columns before the specified column, excluding that column
+     *
+     * - [`all(Cols)After`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsAfter]`(column)`:
+     *     All columns after the specified column, excluding that column
+     *
+     * - [`all(Cols)From`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsFrom]`(column)`:
+     *     All columns from the specified column, including that column
+     *
+     * - [`all(Cols)UpTo`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsUpTo]`(column)`:
+     *     All columns up to the specified column, including that column
+     *
+     * @return A new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns after [column], excluding [column] itself.
+     * @see [allBefore]
+     * @see [allAfter]
+     * @see [allFrom]
+     * @see [allUpTo]
+     * @see [ColumnsSelectionDsl.allExcept]
+     * @see [all]
+     * @see [cols]
+     * @param [column] The specified column after which all columns should be taken. This column can be referenced
+     *   to both relatively to the current [ColumnsResolver][org.jetbrains.kotlinx.dataframe.columns.ColumnsResolver] and absolutely.
+     */
+    public fun KProperty<*>.allColsAfter(column: KProperty<*>): ColumnSet<*> = columnGroup(this).allColsAfter(column)
+
+    /** ## All (Cols) After
+     *
+     * Creates a new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] that contains a subset of columns from [this],
+     * containing all columns after [column], excluding [column] itself.
+     *
+     * [column] can be specified both relative to the current [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup] or the outer scope and
+     * can be referenced using any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi].
+     *
+     * If [column] does not exist, the function will return an empty [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * NOTE: Using the `{}` overloads of these functions requires a [ColumnSelector][org.jetbrains.kotlinx.dataframe.ColumnSelector]
+     * in the Plain DSL and on [column groups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     * On [ColumnSets][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] it requires a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter] instead.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[allAfter][ColumnsSelectionDsl.allAfter]`("someColumn") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup]`(Type::myColGroup).`[allColsAfter][SingleColumn.allColsAfter]`(someColumn) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsOf][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[Int][Int]`>().`[allAfter][ColumnSet.allAfter]`(Type::someColumn) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "pathTo"["someColGroup"].`[allColsAfter][org.jetbrains.kotlinx.dataframe.columns.ColumnPath.allColsAfter]` { myColumn } }`
+     *
+     * #### Flavors of All (Cols):
+     *
+     * - [`all(Cols)`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allCols]`()`:
+     *     All columns
+     *
+     * - [`all(Cols)Before`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsBefore]`(column)`:
+     *     All columns before the specified column, excluding that column
+     *
+     * - [`all(Cols)After`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsAfter]`(column)`:
+     *     All columns after the specified column, excluding that column
+     *
+     * - [`all(Cols)From`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsFrom]`(column)`:
+     *     All columns from the specified column, including that column
+     *
+     * - [`all(Cols)UpTo`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsUpTo]`(column)`:
+     *     All columns up to the specified column, including that column
+     *
+     * @return A new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns after [column], excluding [column] itself.
+     * @see [allBefore]
+     * @see [allAfter]
+     * @see [allFrom]
+     * @see [allUpTo]
+     * @see [ColumnsSelectionDsl.allExcept]
+     * @see [all]
+     * @see [cols]
+     * @param [column] The specified column after which all columns should be taken. This column can be referenced
+     *   to both relatively to the current [ColumnsResolver][org.jetbrains.kotlinx.dataframe.columns.ColumnsResolver] and absolutely.
+     */
+    public fun ColumnPath.allColsAfter(column: ColumnSelector<*, *>): ColumnSet<*> =
+        columnGroup(this).allColsAfter(column)
+
+    /** ## All (Cols) After
+     *
+     * Creates a new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] that contains a subset of columns from [this],
+     * containing all columns after [column], excluding [column] itself.
+     *
+     * [column] can be specified both relative to the current [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup] or the outer scope and
+     * can be referenced using any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi].
+     *
+     * If [column] does not exist, the function will return an empty [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * NOTE: Using the `{}` overloads of these functions requires a [ColumnSelector][org.jetbrains.kotlinx.dataframe.ColumnSelector]
+     * in the Plain DSL and on [column groups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     * On [ColumnSets][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] it requires a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter] instead.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[allAfter][ColumnsSelectionDsl.allAfter]`("someColumn") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup]`(Type::myColGroup).`[allColsAfter][SingleColumn.allColsAfter]`(someColumn) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsOf][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[Int][Int]`>().`[allAfter][ColumnSet.allAfter]`(Type::someColumn) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "pathTo"["someColGroup"].`[allColsAfter][org.jetbrains.kotlinx.dataframe.columns.ColumnPath.allColsAfter]`("pathTo"["myColumn"]) }`
+     *
+     * #### Flavors of All (Cols):
+     *
+     * - [`all(Cols)`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allCols]`()`:
+     *     All columns
+     *
+     * - [`all(Cols)Before`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsBefore]`(column)`:
+     *     All columns before the specified column, excluding that column
+     *
+     * - [`all(Cols)After`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsAfter]`(column)`:
+     *     All columns after the specified column, excluding that column
+     *
+     * - [`all(Cols)From`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsFrom]`(column)`:
+     *     All columns from the specified column, including that column
+     *
+     * - [`all(Cols)UpTo`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsUpTo]`(column)`:
+     *     All columns up to the specified column, including that column
+     *
+     * @return A new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns after [column], excluding [column] itself.
+     * @see [allBefore]
+     * @see [allAfter]
+     * @see [allFrom]
+     * @see [allUpTo]
+     * @see [ColumnsSelectionDsl.allExcept]
+     * @see [all]
+     * @see [cols]
+     * @param [column] The specified column after which all columns should be taken. This column can be referenced
+     *   to both relatively to the current [ColumnsResolver][org.jetbrains.kotlinx.dataframe.columns.ColumnsResolver] and absolutely.
+     */
+    public fun ColumnPath.allColsAfter(column: ColumnPath): ColumnSet<*> = columnGroup(this).allColsAfter(column)
+
+    /** ## All (Cols) After
+     *
+     * Creates a new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] that contains a subset of columns from [this],
+     * containing all columns after [column], excluding [column] itself.
+     *
+     * [column] can be specified both relative to the current [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup] or the outer scope and
+     * can be referenced using any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi].
+     *
+     * If [column] does not exist, the function will return an empty [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * NOTE: Using the `{}` overloads of these functions requires a [ColumnSelector][org.jetbrains.kotlinx.dataframe.ColumnSelector]
+     * in the Plain DSL and on [column groups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     * On [ColumnSets][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] it requires a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter] instead.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[allAfter][ColumnsSelectionDsl.allAfter]`("someColumn") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup]`(Type::myColGroup).`[allColsAfter][SingleColumn.allColsAfter]`(someColumn) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsOf][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[Int][Int]`>().`[allAfter][ColumnSet.allAfter]`(Type::someColumn) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "pathTo"["someColGroup"].`[allColsAfter][org.jetbrains.kotlinx.dataframe.columns.ColumnPath.allColsAfter]`("myColumn") }`
+     *
+     * #### Flavors of All (Cols):
+     *
+     * - [`all(Cols)`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allCols]`()`:
+     *     All columns
+     *
+     * - [`all(Cols)Before`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsBefore]`(column)`:
+     *     All columns before the specified column, excluding that column
+     *
+     * - [`all(Cols)After`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsAfter]`(column)`:
+     *     All columns after the specified column, excluding that column
+     *
+     * - [`all(Cols)From`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsFrom]`(column)`:
+     *     All columns from the specified column, including that column
+     *
+     * - [`all(Cols)UpTo`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsUpTo]`(column)`:
+     *     All columns up to the specified column, including that column
+     *
+     * @return A new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns after [column], excluding [column] itself.
+     * @see [allBefore]
+     * @see [allAfter]
+     * @see [allFrom]
+     * @see [allUpTo]
+     * @see [ColumnsSelectionDsl.allExcept]
+     * @see [all]
+     * @see [cols]
+     * @param [column] The specified column after which all columns should be taken. This column can be referenced
+     *   to both relatively to the current [ColumnsResolver][org.jetbrains.kotlinx.dataframe.columns.ColumnsResolver] and absolutely.
+     */
+    public fun ColumnPath.allColsAfter(column: String): ColumnSet<*> = columnGroup(this).allColsAfter(column)
+
+    /** ## All (Cols) After
+     *
+     * Creates a new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] that contains a subset of columns from [this],
+     * containing all columns after [column], excluding [column] itself.
+     *
+     * [column] can be specified both relative to the current [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup] or the outer scope and
+     * can be referenced using any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi].
+     *
+     * If [column] does not exist, the function will return an empty [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * NOTE: Using the `{}` overloads of these functions requires a [ColumnSelector][org.jetbrains.kotlinx.dataframe.ColumnSelector]
+     * in the Plain DSL and on [column groups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     * On [ColumnSets][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] it requires a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter] instead.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[allAfter][ColumnsSelectionDsl.allAfter]`("someColumn") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup]`(Type::myColGroup).`[allColsAfter][SingleColumn.allColsAfter]`(someColumn) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsOf][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[Int][Int]`>().`[allAfter][ColumnSet.allAfter]`(Type::someColumn) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "pathTo"["someColGroup"].`[allColsAfter][org.jetbrains.kotlinx.dataframe.columns.ColumnPath.allColsAfter]`(myColumn) }`
+     *
+     * #### Flavors of All (Cols):
+     *
+     * - [`all(Cols)`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allCols]`()`:
+     *     All columns
+     *
+     * - [`all(Cols)Before`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsBefore]`(column)`:
+     *     All columns before the specified column, excluding that column
+     *
+     * - [`all(Cols)After`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsAfter]`(column)`:
+     *     All columns after the specified column, excluding that column
+     *
+     * - [`all(Cols)From`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsFrom]`(column)`:
+     *     All columns from the specified column, including that column
+     *
+     * - [`all(Cols)UpTo`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsUpTo]`(column)`:
+     *     All columns up to the specified column, including that column
+     *
+     * @return A new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns after [column], excluding [column] itself.
+     * @see [allBefore]
+     * @see [allAfter]
+     * @see [allFrom]
+     * @see [allUpTo]
+     * @see [ColumnsSelectionDsl.allExcept]
+     * @see [all]
+     * @see [cols]
+     * @param [column] The specified column after which all columns should be taken. This column can be referenced
+     *   to both relatively to the current [ColumnsResolver][org.jetbrains.kotlinx.dataframe.columns.ColumnsResolver] and absolutely.
+     */
+    public fun ColumnPath.allColsAfter(column: AnyColumnReference): ColumnSet<*> =
+        columnGroup(this).allColsAfter(column)
+
+    /** ## All (Cols) After
+     *
+     * Creates a new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] that contains a subset of columns from [this],
+     * containing all columns after [column], excluding [column] itself.
+     *
+     * [column] can be specified both relative to the current [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup] or the outer scope and
+     * can be referenced using any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi].
+     *
+     * If [column] does not exist, the function will return an empty [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * NOTE: Using the `{}` overloads of these functions requires a [ColumnSelector][org.jetbrains.kotlinx.dataframe.ColumnSelector]
+     * in the Plain DSL and on [column groups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     * On [ColumnSets][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] it requires a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter] instead.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[allAfter][ColumnsSelectionDsl.allAfter]`("someColumn") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup]`(Type::myColGroup).`[allColsAfter][SingleColumn.allColsAfter]`(someColumn) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsOf][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[Int][Int]`>().`[allAfter][ColumnSet.allAfter]`(Type::someColumn) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "pathTo"["someColGroup"].`[allColsAfter][org.jetbrains.kotlinx.dataframe.columns.ColumnPath.allColsAfter]`(Type::myColumn) }`
+     *
+     * #### Flavors of All (Cols):
+     *
+     * - [`all(Cols)`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allCols]`()`:
+     *     All columns
+     *
+     * - [`all(Cols)Before`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsBefore]`(column)`:
+     *     All columns before the specified column, excluding that column
+     *
+     * - [`all(Cols)After`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsAfter]`(column)`:
+     *     All columns after the specified column, excluding that column
+     *
+     * - [`all(Cols)From`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsFrom]`(column)`:
+     *     All columns from the specified column, including that column
+     *
+     * - [`all(Cols)UpTo`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsUpTo]`(column)`:
+     *     All columns up to the specified column, including that column
+     *
+     * @return A new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns after [column], excluding [column] itself.
+     * @see [allBefore]
+     * @see [allAfter]
+     * @see [allFrom]
+     * @see [allUpTo]
+     * @see [ColumnsSelectionDsl.allExcept]
+     * @see [all]
+     * @see [cols]
+     * @param [column] The specified column after which all columns should be taken. This column can be referenced
+     *   to both relatively to the current [ColumnsResolver][org.jetbrains.kotlinx.dataframe.columns.ColumnsResolver] and absolutely.
+     */
+    public fun ColumnPath.allColsAfter(column: KProperty<*>): ColumnSet<*> = columnGroup(this).allColsAfter(column)
+
+    // endregion
+
+    // region allFrom
+
+    /**
+     * ## All (Cols) From
+     *
+     * Creates a new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] that contains a subset of columns from [this],
+     * containing all columns from [column], including [column] itself.
+     *
+     * [column] can be specified both relative to the current [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup] or the outer scope and
+     * can be referenced using any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi].
+     *
+     * If [column] does not exist, the function will return an empty [ColumnSet][ColumnSet].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * NOTE: Using the `{}` overloads of these functions requires a [ColumnSelector][org.jetbrains.kotlinx.dataframe.ColumnSelector]
+     * in the Plain DSL and on [column groups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     * On [ColumnSets][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] it requires a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter] instead.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[allFrom][ColumnsSelectionDsl.allFrom]`("someColumn") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup]`(Type::myColGroup).`[allColsFrom][SingleColumn.allColsFrom]`(someColumn) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsOf][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[Int][Int]`>().`[allFrom][ColumnSet.allFrom]`(Type::someColumn) }`
+     *
+     * #### Examples for this overload:
+     *
+     *
+     *
+     * #### Flavors of All (Cols):
+     *
+     * - [`all(Cols)`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allCols]`()`:
+     *     All columns
+     *
+     * - [`all(Cols)Before`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsBefore]`(column)`:
+     *     All columns before the specified column, excluding that column
+     *
+     * - [`all(Cols)After`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsAfter]`(column)`:
+     *     All columns after the specified column, excluding that column
+     *
+     * - [`all(Cols)From`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsFrom]`(column)`:
+     *     All columns from the specified column, including that column
+     *
+     * - [`all(Cols)UpTo`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsUpTo]`(column)`:
+     *     All columns up to the specified column, including that column
+     *
+     * @return A new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns from [column], including [column] itself.
+     * @see [allBefore]
+     * @see [allAfter]
+     * @see [allFrom]
+     * @see [allUpTo]
+     * @see [ColumnsSelectionDsl.allExcept]
+     * @see [all]
+     * @see [cols]
+     * @param [column] The specified column from which all columns should be taken. This column can be referenced
+     *   to both relatively to the current [ColumnsResolver] and absolutely.
+     */
+    private interface AllFromDocs
+
+    /** ## All (Cols) From
+     *
+     * Creates a new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] that contains a subset of columns from [this],
+     * containing all columns from [column], including [column] itself.
+     *
+     * [column] can be specified both relative to the current [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup] or the outer scope and
+     * can be referenced using any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi].
+     *
+     * If [column] does not exist, the function will return an empty [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * NOTE: Using the `{}` overloads of these functions requires a [ColumnSelector][org.jetbrains.kotlinx.dataframe.ColumnSelector]
+     * in the Plain DSL and on [column groups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     * On [ColumnSets][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] it requires a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter] instead.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[allFrom][ColumnsSelectionDsl.allFrom]`("someColumn") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup]`(Type::myColGroup).`[allColsFrom][SingleColumn.allColsFrom]`(someColumn) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsOf][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[Int][Int]`>().`[allFrom][ColumnSet.allFrom]`(Type::someColumn) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]` { .. }.`[allFrom][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.allFrom]` { myColumn `[in][String.contains]` it.`[name][ColumnWithPath.name]` } }`
+     *
+     * #### Flavors of All (Cols):
+     *
+     * - [`all(Cols)`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allCols]`()`:
+     *     All columns
+     *
+     * - [`all(Cols)Before`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsBefore]`(column)`:
+     *     All columns before the specified column, excluding that column
+     *
+     * - [`all(Cols)After`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsAfter]`(column)`:
+     *     All columns after the specified column, excluding that column
+     *
+     * - [`all(Cols)From`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsFrom]`(column)`:
+     *     All columns from the specified column, including that column
+     *
+     * - [`all(Cols)UpTo`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsUpTo]`(column)`:
+     *     All columns up to the specified column, including that column
+     *
+     * @return A new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns from [column], including [column] itself.
+     * @see [allBefore]
+     * @see [allAfter]
+     * @see [allFrom]
+     * @see [allUpTo]
+     * @see [ColumnsSelectionDsl.allExcept]
+     * @see [all]
+     * @see [cols]
+     * @param [column] The specified column from which all columns should be taken. This column can be referenced
+     *   to both relatively to the current [ColumnsResolver][org.jetbrains.kotlinx.dataframe.columns.ColumnsResolver] and absolutely.
+     */
+    @Suppress("UNCHECKED_CAST")
+    public fun <C> ColumnSet<C>.allFrom(column: ColumnFilter<C>): ColumnSet<C> =
+        allFromInternal(column as ColumnFilter<*>) as ColumnSet<C>
+
+    /** ## All (Cols) From
+     *
+     * Creates a new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] that contains a subset of columns from [this],
+     * containing all columns from [column], including [column] itself.
+     *
+     * [column] can be specified both relative to the current [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup] or the outer scope and
+     * can be referenced using any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi].
+     *
+     * If [column] does not exist, the function will return an empty [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * NOTE: Using the `{}` overloads of these functions requires a [ColumnSelector][org.jetbrains.kotlinx.dataframe.ColumnSelector]
+     * in the Plain DSL and on [column groups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     * On [ColumnSets][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] it requires a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter] instead.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[allFrom][ColumnsSelectionDsl.allFrom]`("someColumn") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup]`(Type::myColGroup).`[allColsFrom][SingleColumn.allColsFrom]`(someColumn) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsOf][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[Int][Int]`>().`[allFrom][ColumnSet.allFrom]`(Type::someColumn) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]` { .. }.`[allFrom][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.allFrom]`("pathTo"["myColumn"]) }`
+     *
+     * #### Flavors of All (Cols):
+     *
+     * - [`all(Cols)`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allCols]`()`:
+     *     All columns
+     *
+     * - [`all(Cols)Before`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsBefore]`(column)`:
+     *     All columns before the specified column, excluding that column
+     *
+     * - [`all(Cols)After`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsAfter]`(column)`:
+     *     All columns after the specified column, excluding that column
+     *
+     * - [`all(Cols)From`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsFrom]`(column)`:
+     *     All columns from the specified column, including that column
+     *
+     * - [`all(Cols)UpTo`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsUpTo]`(column)`:
+     *     All columns up to the specified column, including that column
+     *
+     * @return A new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns from [column], including [column] itself.
+     * @see [allBefore]
+     * @see [allAfter]
+     * @see [allFrom]
+     * @see [allUpTo]
+     * @see [ColumnsSelectionDsl.allExcept]
+     * @see [all]
+     * @see [cols]
+     * @param [column] The specified column from which all columns should be taken. This column can be referenced
+     *   to both relatively to the current [ColumnsResolver][org.jetbrains.kotlinx.dataframe.columns.ColumnsResolver] and absolutely.
+     */
+    @Suppress("UNCHECKED_CAST")
+    public fun <C> ColumnSet<C>.allFrom(column: ColumnPath): ColumnSet<C> =
+        allFromInternal { it.path == column } as ColumnSet<C>
+
+    /** ## All (Cols) From
+     *
+     * Creates a new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] that contains a subset of columns from [this],
+     * containing all columns from [column], including [column] itself.
+     *
+     * [column] can be specified both relative to the current [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup] or the outer scope and
+     * can be referenced using any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi].
+     *
+     * If [column] does not exist, the function will return an empty [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * NOTE: Using the `{}` overloads of these functions requires a [ColumnSelector][org.jetbrains.kotlinx.dataframe.ColumnSelector]
+     * in the Plain DSL and on [column groups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     * On [ColumnSets][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] it requires a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter] instead.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[allFrom][ColumnsSelectionDsl.allFrom]`("someColumn") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup]`(Type::myColGroup).`[allColsFrom][SingleColumn.allColsFrom]`(someColumn) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsOf][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[Int][Int]`>().`[allFrom][ColumnSet.allFrom]`(Type::someColumn) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]` { .. }.`[allFrom][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.allFrom]`("myColumn") }`
+     *
+     * #### Flavors of All (Cols):
+     *
+     * - [`all(Cols)`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allCols]`()`:
+     *     All columns
+     *
+     * - [`all(Cols)Before`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsBefore]`(column)`:
+     *     All columns before the specified column, excluding that column
+     *
+     * - [`all(Cols)After`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsAfter]`(column)`:
+     *     All columns after the specified column, excluding that column
+     *
+     * - [`all(Cols)From`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsFrom]`(column)`:
+     *     All columns from the specified column, including that column
+     *
+     * - [`all(Cols)UpTo`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsUpTo]`(column)`:
+     *     All columns up to the specified column, including that column
+     *
+     * @return A new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns from [column], including [column] itself.
+     * @see [allBefore]
+     * @see [allAfter]
+     * @see [allFrom]
+     * @see [allUpTo]
+     * @see [ColumnsSelectionDsl.allExcept]
+     * @see [all]
+     * @see [cols]
+     * @param [column] The specified column from which all columns should be taken. This column can be referenced
+     *   to both relatively to the current [ColumnsResolver][org.jetbrains.kotlinx.dataframe.columns.ColumnsResolver] and absolutely.
+     */
+    public fun <C> ColumnSet<C>.allFrom(column: String): ColumnSet<C> = allFrom(pathOf(column))
+
+    /** ## All (Cols) From
+     *
+     * Creates a new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] that contains a subset of columns from [this],
+     * containing all columns from [column], including [column] itself.
+     *
+     * [column] can be specified both relative to the current [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup] or the outer scope and
+     * can be referenced using any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi].
+     *
+     * If [column] does not exist, the function will return an empty [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * NOTE: Using the `{}` overloads of these functions requires a [ColumnSelector][org.jetbrains.kotlinx.dataframe.ColumnSelector]
+     * in the Plain DSL and on [column groups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     * On [ColumnSets][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] it requires a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter] instead.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[allFrom][ColumnsSelectionDsl.allFrom]`("someColumn") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup]`(Type::myColGroup).`[allColsFrom][SingleColumn.allColsFrom]`(someColumn) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsOf][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[Int][Int]`>().`[allFrom][ColumnSet.allFrom]`(Type::someColumn) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]` { .. }.`[allFrom][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.allFrom]`(myColumn) }`
+     *
+     * #### Flavors of All (Cols):
+     *
+     * - [`all(Cols)`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allCols]`()`:
+     *     All columns
+     *
+     * - [`all(Cols)Before`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsBefore]`(column)`:
+     *     All columns before the specified column, excluding that column
+     *
+     * - [`all(Cols)After`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsAfter]`(column)`:
+     *     All columns after the specified column, excluding that column
+     *
+     * - [`all(Cols)From`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsFrom]`(column)`:
+     *     All columns from the specified column, including that column
+     *
+     * - [`all(Cols)UpTo`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsUpTo]`(column)`:
+     *     All columns up to the specified column, including that column
+     *
+     * @return A new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns from [column], including [column] itself.
+     * @see [allBefore]
+     * @see [allAfter]
+     * @see [allFrom]
+     * @see [allUpTo]
+     * @see [ColumnsSelectionDsl.allExcept]
+     * @see [all]
+     * @see [cols]
+     * @param [column] The specified column from which all columns should be taken. This column can be referenced
+     *   to both relatively to the current [ColumnsResolver][org.jetbrains.kotlinx.dataframe.columns.ColumnsResolver] and absolutely.
+     */
+    public fun <C> ColumnSet<C>.allFrom(column: AnyColumnReference): ColumnSet<C> = allFrom(column.path())
+
+    /** ## All (Cols) From
+     *
+     * Creates a new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] that contains a subset of columns from [this],
+     * containing all columns from [column], including [column] itself.
+     *
+     * [column] can be specified both relative to the current [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup] or the outer scope and
+     * can be referenced using any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi].
+     *
+     * If [column] does not exist, the function will return an empty [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * NOTE: Using the `{}` overloads of these functions requires a [ColumnSelector][org.jetbrains.kotlinx.dataframe.ColumnSelector]
+     * in the Plain DSL and on [column groups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     * On [ColumnSets][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] it requires a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter] instead.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[allFrom][ColumnsSelectionDsl.allFrom]`("someColumn") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup]`(Type::myColGroup).`[allColsFrom][SingleColumn.allColsFrom]`(someColumn) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsOf][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[Int][Int]`>().`[allFrom][ColumnSet.allFrom]`(Type::someColumn) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]` { .. }.`[allFrom][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.allFrom]`(Type::myColumn) }`
+     *
+     * #### Flavors of All (Cols):
+     *
+     * - [`all(Cols)`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allCols]`()`:
+     *     All columns
+     *
+     * - [`all(Cols)Before`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsBefore]`(column)`:
+     *     All columns before the specified column, excluding that column
+     *
+     * - [`all(Cols)After`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsAfter]`(column)`:
+     *     All columns after the specified column, excluding that column
+     *
+     * - [`all(Cols)From`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsFrom]`(column)`:
+     *     All columns from the specified column, including that column
+     *
+     * - [`all(Cols)UpTo`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsUpTo]`(column)`:
+     *     All columns up to the specified column, including that column
+     *
+     * @return A new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns from [column], including [column] itself.
+     * @see [allBefore]
+     * @see [allAfter]
+     * @see [allFrom]
+     * @see [allUpTo]
+     * @see [ColumnsSelectionDsl.allExcept]
+     * @see [all]
+     * @see [cols]
+     * @param [column] The specified column from which all columns should be taken. This column can be referenced
+     *   to both relatively to the current [ColumnsResolver][org.jetbrains.kotlinx.dataframe.columns.ColumnsResolver] and absolutely.
+     */
+    public fun <C> ColumnSet<C>.allFrom(column: KProperty<*>): ColumnSet<C> = allFrom(column.toColumnAccessor().path())
+
+    /** ## All (Cols) From
+     *
+     * Creates a new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] that contains a subset of columns from [this],
+     * containing all columns from [column], including [column] itself.
+     *
+     * [column] can be specified both relative to the current [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup] or the outer scope and
+     * can be referenced using any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi].
+     *
+     * If [column] does not exist, the function will return an empty [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * NOTE: Using the `{}` overloads of these functions requires a [ColumnSelector][org.jetbrains.kotlinx.dataframe.ColumnSelector]
+     * in the Plain DSL and on [column groups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     * On [ColumnSets][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] it requires a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter] instead.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[allFrom][ColumnsSelectionDsl.allFrom]`("someColumn") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup]`(Type::myColGroup).`[allColsFrom][SingleColumn.allColsFrom]`(someColumn) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsOf][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[Int][Int]`>().`[allFrom][ColumnSet.allFrom]`(Type::someColumn) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[allFrom][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.allFrom]` { myColumn } }`
+     *
+     * #### Flavors of All (Cols):
+     *
+     * - [`all(Cols)`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allCols]`()`:
+     *     All columns
+     *
+     * - [`all(Cols)Before`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsBefore]`(column)`:
+     *     All columns before the specified column, excluding that column
+     *
+     * - [`all(Cols)After`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsAfter]`(column)`:
+     *     All columns after the specified column, excluding that column
+     *
+     * - [`all(Cols)From`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsFrom]`(column)`:
+     *     All columns from the specified column, including that column
+     *
+     * - [`all(Cols)UpTo`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsUpTo]`(column)`:
+     *     All columns up to the specified column, including that column
+     *
+     * @return A new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns from [column], including [column] itself.
+     * @see [allBefore]
+     * @see [allAfter]
+     * @see [allFrom]
+     * @see [allUpTo]
+     * @see [ColumnsSelectionDsl.allExcept]
+     * @see [all]
+     * @see [cols]
+     * @param [column] The specified column from which all columns should be taken. This column can be referenced
+     *   to both relatively to the current [ColumnsResolver][org.jetbrains.kotlinx.dataframe.columns.ColumnsResolver] and absolutely.
+     */
+    public fun <T> ColumnsSelectionDsl<T>.allFrom(column: ColumnSelector<T, *>): ColumnSet<*> =
+        asSingleColumn().allColsFrom(column)
+
+    /** ## All (Cols) From
+     *
+     * Creates a new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] that contains a subset of columns from [this],
+     * containing all columns from [column], including [column] itself.
+     *
+     * [column] can be specified both relative to the current [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup] or the outer scope and
+     * can be referenced using any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi].
+     *
+     * If [column] does not exist, the function will return an empty [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * NOTE: Using the `{}` overloads of these functions requires a [ColumnSelector][org.jetbrains.kotlinx.dataframe.ColumnSelector]
+     * in the Plain DSL and on [column groups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     * On [ColumnSets][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] it requires a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter] instead.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[allFrom][ColumnsSelectionDsl.allFrom]`("someColumn") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup]`(Type::myColGroup).`[allColsFrom][SingleColumn.allColsFrom]`(someColumn) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsOf][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[Int][Int]`>().`[allFrom][ColumnSet.allFrom]`(Type::someColumn) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[allFrom][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.allFrom]`("pathTo"["myColumn"]) }`
+     *
+     * #### Flavors of All (Cols):
+     *
+     * - [`all(Cols)`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allCols]`()`:
+     *     All columns
+     *
+     * - [`all(Cols)Before`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsBefore]`(column)`:
+     *     All columns before the specified column, excluding that column
+     *
+     * - [`all(Cols)After`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsAfter]`(column)`:
+     *     All columns after the specified column, excluding that column
+     *
+     * - [`all(Cols)From`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsFrom]`(column)`:
+     *     All columns from the specified column, including that column
+     *
+     * - [`all(Cols)UpTo`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsUpTo]`(column)`:
+     *     All columns up to the specified column, including that column
+     *
+     * @return A new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns from [column], including [column] itself.
+     * @see [allBefore]
+     * @see [allAfter]
+     * @see [allFrom]
+     * @see [allUpTo]
+     * @see [ColumnsSelectionDsl.allExcept]
+     * @see [all]
+     * @see [cols]
+     * @param [column] The specified column from which all columns should be taken. This column can be referenced
+     *   to both relatively to the current [ColumnsResolver][org.jetbrains.kotlinx.dataframe.columns.ColumnsResolver] and absolutely.
+     */
+    public fun ColumnsSelectionDsl<*>.allFrom(column: ColumnPath): ColumnSet<*> = asSingleColumn().allColsFrom(column)
+
+    /** ## All (Cols) From
+     *
+     * Creates a new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] that contains a subset of columns from [this],
+     * containing all columns from [column], including [column] itself.
+     *
+     * [column] can be specified both relative to the current [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup] or the outer scope and
+     * can be referenced using any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi].
+     *
+     * If [column] does not exist, the function will return an empty [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * NOTE: Using the `{}` overloads of these functions requires a [ColumnSelector][org.jetbrains.kotlinx.dataframe.ColumnSelector]
+     * in the Plain DSL and on [column groups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     * On [ColumnSets][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] it requires a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter] instead.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[allFrom][ColumnsSelectionDsl.allFrom]`("someColumn") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup]`(Type::myColGroup).`[allColsFrom][SingleColumn.allColsFrom]`(someColumn) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsOf][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[Int][Int]`>().`[allFrom][ColumnSet.allFrom]`(Type::someColumn) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[allFrom][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.allFrom]`("myColumn") }`
+     *
+     * #### Flavors of All (Cols):
+     *
+     * - [`all(Cols)`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allCols]`()`:
+     *     All columns
+     *
+     * - [`all(Cols)Before`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsBefore]`(column)`:
+     *     All columns before the specified column, excluding that column
+     *
+     * - [`all(Cols)After`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsAfter]`(column)`:
+     *     All columns after the specified column, excluding that column
+     *
+     * - [`all(Cols)From`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsFrom]`(column)`:
+     *     All columns from the specified column, including that column
+     *
+     * - [`all(Cols)UpTo`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsUpTo]`(column)`:
+     *     All columns up to the specified column, including that column
+     *
+     * @return A new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns from [column], including [column] itself.
+     * @see [allBefore]
+     * @see [allAfter]
+     * @see [allFrom]
+     * @see [allUpTo]
+     * @see [ColumnsSelectionDsl.allExcept]
+     * @see [all]
+     * @see [cols]
+     * @param [column] The specified column from which all columns should be taken. This column can be referenced
+     *   to both relatively to the current [ColumnsResolver][org.jetbrains.kotlinx.dataframe.columns.ColumnsResolver] and absolutely.
+     */
+    public fun ColumnsSelectionDsl<*>.allFrom(column: String): ColumnSet<*> = asSingleColumn().allColsFrom(column)
+
+    /** ## All (Cols) From
+     *
+     * Creates a new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] that contains a subset of columns from [this],
+     * containing all columns from [column], including [column] itself.
+     *
+     * [column] can be specified both relative to the current [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup] or the outer scope and
+     * can be referenced using any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi].
+     *
+     * If [column] does not exist, the function will return an empty [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * NOTE: Using the `{}` overloads of these functions requires a [ColumnSelector][org.jetbrains.kotlinx.dataframe.ColumnSelector]
+     * in the Plain DSL and on [column groups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     * On [ColumnSets][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] it requires a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter] instead.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[allFrom][ColumnsSelectionDsl.allFrom]`("someColumn") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup]`(Type::myColGroup).`[allColsFrom][SingleColumn.allColsFrom]`(someColumn) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsOf][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[Int][Int]`>().`[allFrom][ColumnSet.allFrom]`(Type::someColumn) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[allFrom][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.allFrom]`(myColumn) }`
+     *
+     * #### Flavors of All (Cols):
+     *
+     * - [`all(Cols)`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allCols]`()`:
+     *     All columns
+     *
+     * - [`all(Cols)Before`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsBefore]`(column)`:
+     *     All columns before the specified column, excluding that column
+     *
+     * - [`all(Cols)After`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsAfter]`(column)`:
+     *     All columns after the specified column, excluding that column
+     *
+     * - [`all(Cols)From`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsFrom]`(column)`:
+     *     All columns from the specified column, including that column
+     *
+     * - [`all(Cols)UpTo`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsUpTo]`(column)`:
+     *     All columns up to the specified column, including that column
+     *
+     * @return A new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns from [column], including [column] itself.
+     * @see [allBefore]
+     * @see [allAfter]
+     * @see [allFrom]
+     * @see [allUpTo]
+     * @see [ColumnsSelectionDsl.allExcept]
+     * @see [all]
+     * @see [cols]
+     * @param [column] The specified column from which all columns should be taken. This column can be referenced
+     *   to both relatively to the current [ColumnsResolver][org.jetbrains.kotlinx.dataframe.columns.ColumnsResolver] and absolutely.
+     */
+    public fun ColumnsSelectionDsl<*>.allFrom(column: AnyColumnReference): ColumnSet<*> =
+        asSingleColumn().allColsFrom(column)
+
+    /** ## All (Cols) From
+     *
+     * Creates a new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] that contains a subset of columns from [this],
+     * containing all columns from [column], including [column] itself.
+     *
+     * [column] can be specified both relative to the current [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup] or the outer scope and
+     * can be referenced using any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi].
+     *
+     * If [column] does not exist, the function will return an empty [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * NOTE: Using the `{}` overloads of these functions requires a [ColumnSelector][org.jetbrains.kotlinx.dataframe.ColumnSelector]
+     * in the Plain DSL and on [column groups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     * On [ColumnSets][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] it requires a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter] instead.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[allFrom][ColumnsSelectionDsl.allFrom]`("someColumn") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup]`(Type::myColGroup).`[allColsFrom][SingleColumn.allColsFrom]`(someColumn) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsOf][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[Int][Int]`>().`[allFrom][ColumnSet.allFrom]`(Type::someColumn) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[allFrom][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.allFrom]`(Type::myColumn) }`
+     *
+     * #### Flavors of All (Cols):
+     *
+     * - [`all(Cols)`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allCols]`()`:
+     *     All columns
+     *
+     * - [`all(Cols)Before`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsBefore]`(column)`:
+     *     All columns before the specified column, excluding that column
+     *
+     * - [`all(Cols)After`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsAfter]`(column)`:
+     *     All columns after the specified column, excluding that column
+     *
+     * - [`all(Cols)From`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsFrom]`(column)`:
+     *     All columns from the specified column, including that column
+     *
+     * - [`all(Cols)UpTo`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsUpTo]`(column)`:
+     *     All columns up to the specified column, including that column
+     *
+     * @return A new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns from [column], including [column] itself.
+     * @see [allBefore]
+     * @see [allAfter]
+     * @see [allFrom]
+     * @see [allUpTo]
+     * @see [ColumnsSelectionDsl.allExcept]
+     * @see [all]
+     * @see [cols]
+     * @param [column] The specified column from which all columns should be taken. This column can be referenced
+     *   to both relatively to the current [ColumnsResolver][org.jetbrains.kotlinx.dataframe.columns.ColumnsResolver] and absolutely.
+     */
+    public fun ColumnsSelectionDsl<*>.allFrom(column: KProperty<*>): ColumnSet<*> = asSingleColumn().allColsFrom(column)
+
+    /** ## All (Cols) From
+     *
+     * Creates a new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] that contains a subset of columns from [this],
+     * containing all columns from [column], including [column] itself.
+     *
+     * [column] can be specified both relative to the current [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup] or the outer scope and
+     * can be referenced using any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi].
+     *
+     * If [column] does not exist, the function will return an empty [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * NOTE: Using the `{}` overloads of these functions requires a [ColumnSelector][org.jetbrains.kotlinx.dataframe.ColumnSelector]
+     * in the Plain DSL and on [column groups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     * On [ColumnSets][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] it requires a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter] instead.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[allFrom][ColumnsSelectionDsl.allFrom]`("someColumn") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup]`(Type::myColGroup).`[allColsFrom][SingleColumn.allColsFrom]`(someColumn) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsOf][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[Int][Int]`>().`[allFrom][ColumnSet.allFrom]`(Type::someColumn) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { someColumnGroup.`[allColsFrom][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.allColsFrom]` { myColumn } }`
+     *
+     * #### Flavors of All (Cols):
+     *
+     * - [`all(Cols)`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allCols]`()`:
+     *     All columns
+     *
+     * - [`all(Cols)Before`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsBefore]`(column)`:
+     *     All columns before the specified column, excluding that column
+     *
+     * - [`all(Cols)After`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsAfter]`(column)`:
+     *     All columns after the specified column, excluding that column
+     *
+     * - [`all(Cols)From`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsFrom]`(column)`:
+     *     All columns from the specified column, including that column
+     *
+     * - [`all(Cols)UpTo`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsUpTo]`(column)`:
+     *     All columns up to the specified column, including that column
+     *
+     * @return A new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns from [column], including [column] itself.
+     * @see [allBefore]
+     * @see [allAfter]
+     * @see [allFrom]
+     * @see [allUpTo]
+     * @see [ColumnsSelectionDsl.allExcept]
+     * @see [all]
+     * @see [cols]
+     * @param [column] The specified column from which all columns should be taken. This column can be referenced
+     *   to both relatively to the current [ColumnsResolver][org.jetbrains.kotlinx.dataframe.columns.ColumnsResolver] and absolutely.
+     */
+    public fun <T> SingleColumn<DataRow<T>>.allColsFrom(column: ColumnSelector<T, *>): ColumnSet<*> {
+        var resolvedCol: DataColumn<*>? = null
+        return this
+            .ensureIsColumnGroup()
+            .onResolve { resolvedCol = it!!.asColumnGroup().getColumn(column) }
+            .allFromInternal { it.data == resolvedCol!! }
+    }
+
+    /** ## All (Cols) From
+     *
+     * Creates a new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] that contains a subset of columns from [this],
+     * containing all columns from [column], including [column] itself.
+     *
+     * [column] can be specified both relative to the current [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup] or the outer scope and
+     * can be referenced using any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi].
+     *
+     * If [column] does not exist, the function will return an empty [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * NOTE: Using the `{}` overloads of these functions requires a [ColumnSelector][org.jetbrains.kotlinx.dataframe.ColumnSelector]
+     * in the Plain DSL and on [column groups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     * On [ColumnSets][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] it requires a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter] instead.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[allFrom][ColumnsSelectionDsl.allFrom]`("someColumn") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup]`(Type::myColGroup).`[allColsFrom][SingleColumn.allColsFrom]`(someColumn) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsOf][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[Int][Int]`>().`[allFrom][ColumnSet.allFrom]`(Type::someColumn) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { someColumnGroup.`[allColsFrom][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.allColsFrom]`("pathTo"["myColumn"]) }`
+     *
+     * #### Flavors of All (Cols):
+     *
+     * - [`all(Cols)`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allCols]`()`:
+     *     All columns
+     *
+     * - [`all(Cols)Before`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsBefore]`(column)`:
+     *     All columns before the specified column, excluding that column
+     *
+     * - [`all(Cols)After`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsAfter]`(column)`:
+     *     All columns after the specified column, excluding that column
+     *
+     * - [`all(Cols)From`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsFrom]`(column)`:
+     *     All columns from the specified column, including that column
+     *
+     * - [`all(Cols)UpTo`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsUpTo]`(column)`:
+     *     All columns up to the specified column, including that column
+     *
+     * @return A new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns from [column], including [column] itself.
+     * @see [allBefore]
+     * @see [allAfter]
+     * @see [allFrom]
+     * @see [allUpTo]
+     * @see [ColumnsSelectionDsl.allExcept]
+     * @see [all]
+     * @see [cols]
+     * @param [column] The specified column from which all columns should be taken. This column can be referenced
+     *   to both relatively to the current [ColumnsResolver][org.jetbrains.kotlinx.dataframe.columns.ColumnsResolver] and absolutely.
+     */
+    public fun SingleColumn<DataRow<*>>.allColsFrom(column: ColumnPath): ColumnSet<*> {
+        var path: ColumnPath? = null
+        return this
+            .ensureIsColumnGroup()
+            .onResolve { path = it!!.path }
+            .allFromInternal {
+                // accept both relative and full column path
+                it.path == path!! + column || it.path == column
+            }
+    }
+
+    /** ## All (Cols) From
+     *
+     * Creates a new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] that contains a subset of columns from [this],
+     * containing all columns from [column], including [column] itself.
+     *
+     * [column] can be specified both relative to the current [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup] or the outer scope and
+     * can be referenced using any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi].
+     *
+     * If [column] does not exist, the function will return an empty [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * NOTE: Using the `{}` overloads of these functions requires a [ColumnSelector][org.jetbrains.kotlinx.dataframe.ColumnSelector]
+     * in the Plain DSL and on [column groups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     * On [ColumnSets][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] it requires a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter] instead.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[allFrom][ColumnsSelectionDsl.allFrom]`("someColumn") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup]`(Type::myColGroup).`[allColsFrom][SingleColumn.allColsFrom]`(someColumn) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsOf][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[Int][Int]`>().`[allFrom][ColumnSet.allFrom]`(Type::someColumn) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { someColumnGroup.`[allColsFrom][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.allColsFrom]`("myColumn") }`
+     *
+     * #### Flavors of All (Cols):
+     *
+     * - [`all(Cols)`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allCols]`()`:
+     *     All columns
+     *
+     * - [`all(Cols)Before`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsBefore]`(column)`:
+     *     All columns before the specified column, excluding that column
+     *
+     * - [`all(Cols)After`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsAfter]`(column)`:
+     *     All columns after the specified column, excluding that column
+     *
+     * - [`all(Cols)From`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsFrom]`(column)`:
+     *     All columns from the specified column, including that column
+     *
+     * - [`all(Cols)UpTo`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsUpTo]`(column)`:
+     *     All columns up to the specified column, including that column
+     *
+     * @return A new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns from [column], including [column] itself.
+     * @see [allBefore]
+     * @see [allAfter]
+     * @see [allFrom]
+     * @see [allUpTo]
+     * @see [ColumnsSelectionDsl.allExcept]
+     * @see [all]
+     * @see [cols]
+     * @param [column] The specified column from which all columns should be taken. This column can be referenced
+     *   to both relatively to the current [ColumnsResolver][org.jetbrains.kotlinx.dataframe.columns.ColumnsResolver] and absolutely.
+     */
+    public fun SingleColumn<DataRow<*>>.allColsFrom(column: String): ColumnSet<*> = allColsFrom(pathOf(column))
+
+    /** ## All (Cols) From
+     *
+     * Creates a new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] that contains a subset of columns from [this],
+     * containing all columns from [column], including [column] itself.
+     *
+     * [column] can be specified both relative to the current [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup] or the outer scope and
+     * can be referenced using any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi].
+     *
+     * If [column] does not exist, the function will return an empty [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * NOTE: Using the `{}` overloads of these functions requires a [ColumnSelector][org.jetbrains.kotlinx.dataframe.ColumnSelector]
+     * in the Plain DSL and on [column groups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     * On [ColumnSets][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] it requires a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter] instead.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[allFrom][ColumnsSelectionDsl.allFrom]`("someColumn") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup]`(Type::myColGroup).`[allColsFrom][SingleColumn.allColsFrom]`(someColumn) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsOf][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[Int][Int]`>().`[allFrom][ColumnSet.allFrom]`(Type::someColumn) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { someColumnGroup.`[allColsFrom][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.allColsFrom]`(myColumn) }`
+     *
+     * #### Flavors of All (Cols):
+     *
+     * - [`all(Cols)`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allCols]`()`:
+     *     All columns
+     *
+     * - [`all(Cols)Before`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsBefore]`(column)`:
+     *     All columns before the specified column, excluding that column
+     *
+     * - [`all(Cols)After`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsAfter]`(column)`:
+     *     All columns after the specified column, excluding that column
+     *
+     * - [`all(Cols)From`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsFrom]`(column)`:
+     *     All columns from the specified column, including that column
+     *
+     * - [`all(Cols)UpTo`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsUpTo]`(column)`:
+     *     All columns up to the specified column, including that column
+     *
+     * @return A new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns from [column], including [column] itself.
+     * @see [allBefore]
+     * @see [allAfter]
+     * @see [allFrom]
+     * @see [allUpTo]
+     * @see [ColumnsSelectionDsl.allExcept]
+     * @see [all]
+     * @see [cols]
+     * @param [column] The specified column from which all columns should be taken. This column can be referenced
+     *   to both relatively to the current [ColumnsResolver][org.jetbrains.kotlinx.dataframe.columns.ColumnsResolver] and absolutely.
+     */
+    public fun SingleColumn<DataRow<*>>.allColsFrom(column: AnyColumnReference): ColumnSet<*> =
+        allColsFrom(column.path())
+
+    /** ## All (Cols) From
+     *
+     * Creates a new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] that contains a subset of columns from [this],
+     * containing all columns from [column], including [column] itself.
+     *
+     * [column] can be specified both relative to the current [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup] or the outer scope and
+     * can be referenced using any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi].
+     *
+     * If [column] does not exist, the function will return an empty [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * NOTE: Using the `{}` overloads of these functions requires a [ColumnSelector][org.jetbrains.kotlinx.dataframe.ColumnSelector]
+     * in the Plain DSL and on [column groups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     * On [ColumnSets][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] it requires a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter] instead.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[allFrom][ColumnsSelectionDsl.allFrom]`("someColumn") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup]`(Type::myColGroup).`[allColsFrom][SingleColumn.allColsFrom]`(someColumn) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsOf][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[Int][Int]`>().`[allFrom][ColumnSet.allFrom]`(Type::someColumn) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { someColumnGroup.`[allColsFrom][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.allColsFrom]`(Type::myColumn) }`
+     *
+     * #### Flavors of All (Cols):
+     *
+     * - [`all(Cols)`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allCols]`()`:
+     *     All columns
+     *
+     * - [`all(Cols)Before`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsBefore]`(column)`:
+     *     All columns before the specified column, excluding that column
+     *
+     * - [`all(Cols)After`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsAfter]`(column)`:
+     *     All columns after the specified column, excluding that column
+     *
+     * - [`all(Cols)From`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsFrom]`(column)`:
+     *     All columns from the specified column, including that column
+     *
+     * - [`all(Cols)UpTo`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsUpTo]`(column)`:
+     *     All columns up to the specified column, including that column
+     *
+     * @return A new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns from [column], including [column] itself.
+     * @see [allBefore]
+     * @see [allAfter]
+     * @see [allFrom]
+     * @see [allUpTo]
+     * @see [ColumnsSelectionDsl.allExcept]
+     * @see [all]
+     * @see [cols]
+     * @param [column] The specified column from which all columns should be taken. This column can be referenced
+     *   to both relatively to the current [ColumnsResolver][org.jetbrains.kotlinx.dataframe.columns.ColumnsResolver] and absolutely.
+     */
+    public fun SingleColumn<DataRow<*>>.allColsFrom(column: KProperty<*>): ColumnSet<*> =
+        allColsFrom(column.toColumnAccessor().path())
+
+    /** ## All (Cols) From
+     *
+     * Creates a new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] that contains a subset of columns from [this],
+     * containing all columns from [column], including [column] itself.
+     *
+     * [column] can be specified both relative to the current [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup] or the outer scope and
+     * can be referenced using any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi].
+     *
+     * If [column] does not exist, the function will return an empty [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * NOTE: Using the `{}` overloads of these functions requires a [ColumnSelector][org.jetbrains.kotlinx.dataframe.ColumnSelector]
+     * in the Plain DSL and on [column groups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     * On [ColumnSets][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] it requires a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter] instead.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[allFrom][ColumnsSelectionDsl.allFrom]`("someColumn") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup]`(Type::myColGroup).`[allColsFrom][SingleColumn.allColsFrom]`(someColumn) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsOf][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[Int][Int]`>().`[allFrom][ColumnSet.allFrom]`(Type::someColumn) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "someColGroup".`[allColsFrom][kotlin.String.allColsFrom]` { myColumn } }`
+     *
+     * #### Flavors of All (Cols):
+     *
+     * - [`all(Cols)`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allCols]`()`:
+     *     All columns
+     *
+     * - [`all(Cols)Before`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsBefore]`(column)`:
+     *     All columns before the specified column, excluding that column
+     *
+     * - [`all(Cols)After`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsAfter]`(column)`:
+     *     All columns after the specified column, excluding that column
+     *
+     * - [`all(Cols)From`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsFrom]`(column)`:
+     *     All columns from the specified column, including that column
+     *
+     * - [`all(Cols)UpTo`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsUpTo]`(column)`:
+     *     All columns up to the specified column, including that column
+     *
+     * @return A new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns from [column], including [column] itself.
+     * @see [allBefore]
+     * @see [allAfter]
+     * @see [allFrom]
+     * @see [allUpTo]
+     * @see [ColumnsSelectionDsl.allExcept]
+     * @see [all]
+     * @see [cols]
+     * @param [column] The specified column from which all columns should be taken. This column can be referenced
+     *   to both relatively to the current [ColumnsResolver][org.jetbrains.kotlinx.dataframe.columns.ColumnsResolver] and absolutely.
+     */
+    public fun String.allColsFrom(column: ColumnSelector<*, *>): ColumnSet<*> = columnGroup(this).allColsFrom(column)
+
+    /** ## All (Cols) From
+     *
+     * Creates a new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] that contains a subset of columns from [this],
+     * containing all columns from [column], including [column] itself.
+     *
+     * [column] can be specified both relative to the current [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup] or the outer scope and
+     * can be referenced using any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi].
+     *
+     * If [column] does not exist, the function will return an empty [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * NOTE: Using the `{}` overloads of these functions requires a [ColumnSelector][org.jetbrains.kotlinx.dataframe.ColumnSelector]
+     * in the Plain DSL and on [column groups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     * On [ColumnSets][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] it requires a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter] instead.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[allFrom][ColumnsSelectionDsl.allFrom]`("someColumn") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup]`(Type::myColGroup).`[allColsFrom][SingleColumn.allColsFrom]`(someColumn) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsOf][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[Int][Int]`>().`[allFrom][ColumnSet.allFrom]`(Type::someColumn) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "someColGroup".`[allColsFrom][kotlin.String.allColsFrom]`("pathTo"["myColumn"]) }`
+     *
+     * #### Flavors of All (Cols):
+     *
+     * - [`all(Cols)`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allCols]`()`:
+     *     All columns
+     *
+     * - [`all(Cols)Before`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsBefore]`(column)`:
+     *     All columns before the specified column, excluding that column
+     *
+     * - [`all(Cols)After`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsAfter]`(column)`:
+     *     All columns after the specified column, excluding that column
+     *
+     * - [`all(Cols)From`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsFrom]`(column)`:
+     *     All columns from the specified column, including that column
+     *
+     * - [`all(Cols)UpTo`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsUpTo]`(column)`:
+     *     All columns up to the specified column, including that column
+     *
+     * @return A new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns from [column], including [column] itself.
+     * @see [allBefore]
+     * @see [allAfter]
+     * @see [allFrom]
+     * @see [allUpTo]
+     * @see [ColumnsSelectionDsl.allExcept]
+     * @see [all]
+     * @see [cols]
+     * @param [column] The specified column from which all columns should be taken. This column can be referenced
+     *   to both relatively to the current [ColumnsResolver][org.jetbrains.kotlinx.dataframe.columns.ColumnsResolver] and absolutely.
+     */
+    public fun String.allColsFrom(column: ColumnPath): ColumnSet<*> = columnGroup(this).allColsFrom(column)
+
+    /** ## All (Cols) From
+     *
+     * Creates a new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] that contains a subset of columns from [this],
+     * containing all columns from [column], including [column] itself.
+     *
+     * [column] can be specified both relative to the current [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup] or the outer scope and
+     * can be referenced using any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi].
+     *
+     * If [column] does not exist, the function will return an empty [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * NOTE: Using the `{}` overloads of these functions requires a [ColumnSelector][org.jetbrains.kotlinx.dataframe.ColumnSelector]
+     * in the Plain DSL and on [column groups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     * On [ColumnSets][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] it requires a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter] instead.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[allFrom][ColumnsSelectionDsl.allFrom]`("someColumn") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup]`(Type::myColGroup).`[allColsFrom][SingleColumn.allColsFrom]`(someColumn) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsOf][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[Int][Int]`>().`[allFrom][ColumnSet.allFrom]`(Type::someColumn) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "someColGroup".`[allColsFrom][kotlin.String.allColsFrom]`("myColumn") }`
+     *
+     * #### Flavors of All (Cols):
+     *
+     * - [`all(Cols)`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allCols]`()`:
+     *     All columns
+     *
+     * - [`all(Cols)Before`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsBefore]`(column)`:
+     *     All columns before the specified column, excluding that column
+     *
+     * - [`all(Cols)After`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsAfter]`(column)`:
+     *     All columns after the specified column, excluding that column
+     *
+     * - [`all(Cols)From`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsFrom]`(column)`:
+     *     All columns from the specified column, including that column
+     *
+     * - [`all(Cols)UpTo`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsUpTo]`(column)`:
+     *     All columns up to the specified column, including that column
+     *
+     * @return A new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns from [column], including [column] itself.
+     * @see [allBefore]
+     * @see [allAfter]
+     * @see [allFrom]
+     * @see [allUpTo]
+     * @see [ColumnsSelectionDsl.allExcept]
+     * @see [all]
+     * @see [cols]
+     * @param [column] The specified column from which all columns should be taken. This column can be referenced
+     *   to both relatively to the current [ColumnsResolver][org.jetbrains.kotlinx.dataframe.columns.ColumnsResolver] and absolutely.
+     */
+    public fun String.allColsFrom(column: String): ColumnSet<*> = columnGroup(this).allColsFrom(column)
+
+    /** ## All (Cols) From
+     *
+     * Creates a new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] that contains a subset of columns from [this],
+     * containing all columns from [column], including [column] itself.
+     *
+     * [column] can be specified both relative to the current [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup] or the outer scope and
+     * can be referenced using any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi].
+     *
+     * If [column] does not exist, the function will return an empty [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * NOTE: Using the `{}` overloads of these functions requires a [ColumnSelector][org.jetbrains.kotlinx.dataframe.ColumnSelector]
+     * in the Plain DSL and on [column groups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     * On [ColumnSets][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] it requires a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter] instead.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[allFrom][ColumnsSelectionDsl.allFrom]`("someColumn") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup]`(Type::myColGroup).`[allColsFrom][SingleColumn.allColsFrom]`(someColumn) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsOf][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[Int][Int]`>().`[allFrom][ColumnSet.allFrom]`(Type::someColumn) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "someColGroup".`[allColsFrom][kotlin.String.allColsFrom]`(myColumn) }`
+     *
+     * #### Flavors of All (Cols):
+     *
+     * - [`all(Cols)`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allCols]`()`:
+     *     All columns
+     *
+     * - [`all(Cols)Before`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsBefore]`(column)`:
+     *     All columns before the specified column, excluding that column
+     *
+     * - [`all(Cols)After`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsAfter]`(column)`:
+     *     All columns after the specified column, excluding that column
+     *
+     * - [`all(Cols)From`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsFrom]`(column)`:
+     *     All columns from the specified column, including that column
+     *
+     * - [`all(Cols)UpTo`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsUpTo]`(column)`:
+     *     All columns up to the specified column, including that column
+     *
+     * @return A new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns from [column], including [column] itself.
+     * @see [allBefore]
+     * @see [allAfter]
+     * @see [allFrom]
+     * @see [allUpTo]
+     * @see [ColumnsSelectionDsl.allExcept]
+     * @see [all]
+     * @see [cols]
+     * @param [column] The specified column from which all columns should be taken. This column can be referenced
+     *   to both relatively to the current [ColumnsResolver][org.jetbrains.kotlinx.dataframe.columns.ColumnsResolver] and absolutely.
+     */
+    public fun String.allColsFrom(column: AnyColumnReference): ColumnSet<*> = columnGroup(this).allColsFrom(column)
+
+    /** ## All (Cols) From
+     *
+     * Creates a new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] that contains a subset of columns from [this],
+     * containing all columns from [column], including [column] itself.
+     *
+     * [column] can be specified both relative to the current [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup] or the outer scope and
+     * can be referenced using any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi].
+     *
+     * If [column] does not exist, the function will return an empty [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * NOTE: Using the `{}` overloads of these functions requires a [ColumnSelector][org.jetbrains.kotlinx.dataframe.ColumnSelector]
+     * in the Plain DSL and on [column groups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     * On [ColumnSets][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] it requires a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter] instead.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[allFrom][ColumnsSelectionDsl.allFrom]`("someColumn") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup]`(Type::myColGroup).`[allColsFrom][SingleColumn.allColsFrom]`(someColumn) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsOf][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[Int][Int]`>().`[allFrom][ColumnSet.allFrom]`(Type::someColumn) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "someColGroup".`[allColsFrom][kotlin.String.allColsFrom]`(Type::myColumn) }`
+     *
+     * #### Flavors of All (Cols):
+     *
+     * - [`all(Cols)`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allCols]`()`:
+     *     All columns
+     *
+     * - [`all(Cols)Before`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsBefore]`(column)`:
+     *     All columns before the specified column, excluding that column
+     *
+     * - [`all(Cols)After`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsAfter]`(column)`:
+     *     All columns after the specified column, excluding that column
+     *
+     * - [`all(Cols)From`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsFrom]`(column)`:
+     *     All columns from the specified column, including that column
+     *
+     * - [`all(Cols)UpTo`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsUpTo]`(column)`:
+     *     All columns up to the specified column, including that column
+     *
+     * @return A new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns from [column], including [column] itself.
+     * @see [allBefore]
+     * @see [allAfter]
+     * @see [allFrom]
+     * @see [allUpTo]
+     * @see [ColumnsSelectionDsl.allExcept]
+     * @see [all]
+     * @see [cols]
+     * @param [column] The specified column from which all columns should be taken. This column can be referenced
+     *   to both relatively to the current [ColumnsResolver][org.jetbrains.kotlinx.dataframe.columns.ColumnsResolver] and absolutely.
+     */
+    public fun String.allColsFrom(column: KProperty<*>): ColumnSet<*> = columnGroup(this).allColsFrom(column)
+
+    /**
+     * ## All (Cols) From
+     *
+     * Creates a new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] that contains a subset of columns from [this],
+     * containing all columns from [column], including [column] itself.
+     *
+     * [column] can be specified both relative to the current [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup] or the outer scope and
+     * can be referenced using any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi].
+     *
+     * If [column] does not exist, the function will return an empty [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * NOTE: Using the `{}` overloads of these functions requires a [ColumnSelector][org.jetbrains.kotlinx.dataframe.ColumnSelector]
+     * in the Plain DSL and on [column groups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     * On [ColumnSets][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] it requires a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter] instead.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[allFrom][ColumnsSelectionDsl.allFrom]`("someColumn") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup]`(Type::myColGroup).`[allColsFrom][SingleColumn.allColsFrom]`(someColumn) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsOf][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[Int][Int]`>().`[allFrom][ColumnSet.allFrom]`(Type::someColumn) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { DataSchemaType::someColGroup.`[allColsFrom][kotlin.reflect.KProperty.allColsFrom]` { myColumn } }`
+     *
+     * #### Flavors of All (Cols):
+     *
+     * - [`all(Cols)`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allCols]`()`:
+     *     All columns
+     *
+     * - [`all(Cols)Before`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsBefore]`(column)`:
+     *     All columns before the specified column, excluding that column
+     *
+     * - [`all(Cols)After`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsAfter]`(column)`:
+     *     All columns after the specified column, excluding that column
+     *
+     * - [`all(Cols)From`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsFrom]`(column)`:
+     *     All columns from the specified column, including that column
+     *
+     * - [`all(Cols)UpTo`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsUpTo]`(column)`:
+     *     All columns up to the specified column, including that column
+     *
+     * @return A new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns from [column], including [column] itself.
+     * @see [allBefore]
+     * @see [allAfter]
+     * @see [allFrom]
+     * @see [allUpTo]
+     * @see [ColumnsSelectionDsl.allExcept]
+     * @see [all]
+     * @see [cols]
+     * @param [column] The specified column from which all columns should be taken. This column can be referenced
+     *   to both relatively to the current [ColumnsResolver][org.jetbrains.kotlinx.dataframe.columns.ColumnsResolver] and absolutely.
+     */
+    public fun <C> KProperty<C>.allColsFrom(column: ColumnSelector<C, *>): ColumnSet<*> =
+        columnGroup(this).allColsFrom(column)
+
+    /** ## All (Cols) From
+     *
+     * Creates a new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] that contains a subset of columns from [this],
+     * containing all columns from [column], including [column] itself.
+     *
+     * [column] can be specified both relative to the current [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup] or the outer scope and
+     * can be referenced using any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi].
+     *
+     * If [column] does not exist, the function will return an empty [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * NOTE: Using the `{}` overloads of these functions requires a [ColumnSelector][org.jetbrains.kotlinx.dataframe.ColumnSelector]
+     * in the Plain DSL and on [column groups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     * On [ColumnSets][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] it requires a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter] instead.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[allFrom][ColumnsSelectionDsl.allFrom]`("someColumn") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup]`(Type::myColGroup).`[allColsFrom][SingleColumn.allColsFrom]`(someColumn) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsOf][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[Int][Int]`>().`[allFrom][ColumnSet.allFrom]`(Type::someColumn) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { DataSchemaType::someColGroup.`[allColsFrom][kotlin.reflect.KProperty.allColsFrom]`("pathTo"["myColumn"]) }`
+     *
+     * #### Flavors of All (Cols):
+     *
+     * - [`all(Cols)`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allCols]`()`:
+     *     All columns
+     *
+     * - [`all(Cols)Before`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsBefore]`(column)`:
+     *     All columns before the specified column, excluding that column
+     *
+     * - [`all(Cols)After`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsAfter]`(column)`:
+     *     All columns after the specified column, excluding that column
+     *
+     * - [`all(Cols)From`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsFrom]`(column)`:
+     *     All columns from the specified column, including that column
+     *
+     * - [`all(Cols)UpTo`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsUpTo]`(column)`:
+     *     All columns up to the specified column, including that column
+     *
+     * @return A new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns from [column], including [column] itself.
+     * @see [allBefore]
+     * @see [allAfter]
+     * @see [allFrom]
+     * @see [allUpTo]
+     * @see [ColumnsSelectionDsl.allExcept]
+     * @see [all]
+     * @see [cols]
+     * @param [column] The specified column from which all columns should be taken. This column can be referenced
+     *   to both relatively to the current [ColumnsResolver][org.jetbrains.kotlinx.dataframe.columns.ColumnsResolver] and absolutely.
+     */
+    public fun KProperty<*>.allColsFrom(column: ColumnPath): ColumnSet<*> = columnGroup(this).allColsFrom(column)
+
+    /** ## All (Cols) From
+     *
+     * Creates a new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] that contains a subset of columns from [this],
+     * containing all columns from [column], including [column] itself.
+     *
+     * [column] can be specified both relative to the current [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup] or the outer scope and
+     * can be referenced using any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi].
+     *
+     * If [column] does not exist, the function will return an empty [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * NOTE: Using the `{}` overloads of these functions requires a [ColumnSelector][org.jetbrains.kotlinx.dataframe.ColumnSelector]
+     * in the Plain DSL and on [column groups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     * On [ColumnSets][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] it requires a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter] instead.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[allFrom][ColumnsSelectionDsl.allFrom]`("someColumn") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup]`(Type::myColGroup).`[allColsFrom][SingleColumn.allColsFrom]`(someColumn) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsOf][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[Int][Int]`>().`[allFrom][ColumnSet.allFrom]`(Type::someColumn) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { DataSchemaType::someColGroup.`[allColsFrom][kotlin.reflect.KProperty.allColsFrom]`("myColumn") }`
+     *
+     * #### Flavors of All (Cols):
+     *
+     * - [`all(Cols)`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allCols]`()`:
+     *     All columns
+     *
+     * - [`all(Cols)Before`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsBefore]`(column)`:
+     *     All columns before the specified column, excluding that column
+     *
+     * - [`all(Cols)After`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsAfter]`(column)`:
+     *     All columns after the specified column, excluding that column
+     *
+     * - [`all(Cols)From`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsFrom]`(column)`:
+     *     All columns from the specified column, including that column
+     *
+     * - [`all(Cols)UpTo`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsUpTo]`(column)`:
+     *     All columns up to the specified column, including that column
+     *
+     * @return A new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns from [column], including [column] itself.
+     * @see [allBefore]
+     * @see [allAfter]
+     * @see [allFrom]
+     * @see [allUpTo]
+     * @see [ColumnsSelectionDsl.allExcept]
+     * @see [all]
+     * @see [cols]
+     * @param [column] The specified column from which all columns should be taken. This column can be referenced
+     *   to both relatively to the current [ColumnsResolver][org.jetbrains.kotlinx.dataframe.columns.ColumnsResolver] and absolutely.
+     */
+    public fun KProperty<*>.allColsFrom(column: String): ColumnSet<*> = columnGroup(this).allColsFrom(column)
+
+    /** ## All (Cols) From
+     *
+     * Creates a new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] that contains a subset of columns from [this],
+     * containing all columns from [column], including [column] itself.
+     *
+     * [column] can be specified both relative to the current [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup] or the outer scope and
+     * can be referenced using any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi].
+     *
+     * If [column] does not exist, the function will return an empty [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * NOTE: Using the `{}` overloads of these functions requires a [ColumnSelector][org.jetbrains.kotlinx.dataframe.ColumnSelector]
+     * in the Plain DSL and on [column groups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     * On [ColumnSets][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] it requires a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter] instead.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[allFrom][ColumnsSelectionDsl.allFrom]`("someColumn") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup]`(Type::myColGroup).`[allColsFrom][SingleColumn.allColsFrom]`(someColumn) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsOf][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[Int][Int]`>().`[allFrom][ColumnSet.allFrom]`(Type::someColumn) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { DataSchemaType::someColGroup.`[allColsFrom][kotlin.reflect.KProperty.allColsFrom]`(myColumn) }`
+     *
+     * #### Flavors of All (Cols):
+     *
+     * - [`all(Cols)`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allCols]`()`:
+     *     All columns
+     *
+     * - [`all(Cols)Before`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsBefore]`(column)`:
+     *     All columns before the specified column, excluding that column
+     *
+     * - [`all(Cols)After`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsAfter]`(column)`:
+     *     All columns after the specified column, excluding that column
+     *
+     * - [`all(Cols)From`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsFrom]`(column)`:
+     *     All columns from the specified column, including that column
+     *
+     * - [`all(Cols)UpTo`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsUpTo]`(column)`:
+     *     All columns up to the specified column, including that column
+     *
+     * @return A new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns from [column], including [column] itself.
+     * @see [allBefore]
+     * @see [allAfter]
+     * @see [allFrom]
+     * @see [allUpTo]
+     * @see [ColumnsSelectionDsl.allExcept]
+     * @see [all]
+     * @see [cols]
+     * @param [column] The specified column from which all columns should be taken. This column can be referenced
+     *   to both relatively to the current [ColumnsResolver][org.jetbrains.kotlinx.dataframe.columns.ColumnsResolver] and absolutely.
+     */
+    public fun KProperty<*>.allColsFrom(column: AnyColumnReference): ColumnSet<*> =
+        columnGroup(this).allColsFrom(column)
+
+    /** ## All (Cols) From
+     *
+     * Creates a new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] that contains a subset of columns from [this],
+     * containing all columns from [column], including [column] itself.
+     *
+     * [column] can be specified both relative to the current [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup] or the outer scope and
+     * can be referenced using any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi].
+     *
+     * If [column] does not exist, the function will return an empty [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * NOTE: Using the `{}` overloads of these functions requires a [ColumnSelector][org.jetbrains.kotlinx.dataframe.ColumnSelector]
+     * in the Plain DSL and on [column groups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     * On [ColumnSets][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] it requires a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter] instead.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[allFrom][ColumnsSelectionDsl.allFrom]`("someColumn") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup]`(Type::myColGroup).`[allColsFrom][SingleColumn.allColsFrom]`(someColumn) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsOf][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[Int][Int]`>().`[allFrom][ColumnSet.allFrom]`(Type::someColumn) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { DataSchemaType::someColGroup.`[allColsFrom][kotlin.reflect.KProperty.allColsFrom]`(Type::myColumn) }`
+     *
+     * #### Flavors of All (Cols):
+     *
+     * - [`all(Cols)`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allCols]`()`:
+     *     All columns
+     *
+     * - [`all(Cols)Before`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsBefore]`(column)`:
+     *     All columns before the specified column, excluding that column
+     *
+     * - [`all(Cols)After`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsAfter]`(column)`:
+     *     All columns after the specified column, excluding that column
+     *
+     * - [`all(Cols)From`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsFrom]`(column)`:
+     *     All columns from the specified column, including that column
+     *
+     * - [`all(Cols)UpTo`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsUpTo]`(column)`:
+     *     All columns up to the specified column, including that column
+     *
+     * @return A new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns from [column], including [column] itself.
+     * @see [allBefore]
+     * @see [allAfter]
+     * @see [allFrom]
+     * @see [allUpTo]
+     * @see [ColumnsSelectionDsl.allExcept]
+     * @see [all]
+     * @see [cols]
+     * @param [column] The specified column from which all columns should be taken. This column can be referenced
+     *   to both relatively to the current [ColumnsResolver][org.jetbrains.kotlinx.dataframe.columns.ColumnsResolver] and absolutely.
+     */
+    public fun KProperty<*>.allColsFrom(column: KProperty<*>): ColumnSet<*> = columnGroup(this).allColsFrom(column)
+
+    /** ## All (Cols) From
+     *
+     * Creates a new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] that contains a subset of columns from [this],
+     * containing all columns from [column], including [column] itself.
+     *
+     * [column] can be specified both relative to the current [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup] or the outer scope and
+     * can be referenced using any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi].
+     *
+     * If [column] does not exist, the function will return an empty [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * NOTE: Using the `{}` overloads of these functions requires a [ColumnSelector][org.jetbrains.kotlinx.dataframe.ColumnSelector]
+     * in the Plain DSL and on [column groups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     * On [ColumnSets][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] it requires a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter] instead.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[allFrom][ColumnsSelectionDsl.allFrom]`("someColumn") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup]`(Type::myColGroup).`[allColsFrom][SingleColumn.allColsFrom]`(someColumn) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsOf][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[Int][Int]`>().`[allFrom][ColumnSet.allFrom]`(Type::someColumn) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "pathTo"["someColGroup"].`[allFrom][org.jetbrains.kotlinx.dataframe.columns.ColumnPath.allColsFrom]` { myColumn } }`
+     *
+     * #### Flavors of All (Cols):
+     *
+     * - [`all(Cols)`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allCols]`()`:
+     *     All columns
+     *
+     * - [`all(Cols)Before`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsBefore]`(column)`:
+     *     All columns before the specified column, excluding that column
+     *
+     * - [`all(Cols)After`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsAfter]`(column)`:
+     *     All columns after the specified column, excluding that column
+     *
+     * - [`all(Cols)From`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsFrom]`(column)`:
+     *     All columns from the specified column, including that column
+     *
+     * - [`all(Cols)UpTo`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsUpTo]`(column)`:
+     *     All columns up to the specified column, including that column
+     *
+     * @return A new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns from [column], including [column] itself.
+     * @see [allBefore]
+     * @see [allAfter]
+     * @see [allFrom]
+     * @see [allUpTo]
+     * @see [ColumnsSelectionDsl.allExcept]
+     * @see [all]
+     * @see [cols]
+     * @param [column] The specified column from which all columns should be taken. This column can be referenced
+     *   to both relatively to the current [ColumnsResolver][org.jetbrains.kotlinx.dataframe.columns.ColumnsResolver] and absolutely.
+     */
+    public fun ColumnPath.allColsFrom(column: ColumnSelector<*, *>): ColumnSet<*> =
+        columnGroup(this).allColsFrom(column)
+
+    /** ## All (Cols) From
+     *
+     * Creates a new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] that contains a subset of columns from [this],
+     * containing all columns from [column], including [column] itself.
+     *
+     * [column] can be specified both relative to the current [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup] or the outer scope and
+     * can be referenced using any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi].
+     *
+     * If [column] does not exist, the function will return an empty [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * NOTE: Using the `{}` overloads of these functions requires a [ColumnSelector][org.jetbrains.kotlinx.dataframe.ColumnSelector]
+     * in the Plain DSL and on [column groups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     * On [ColumnSets][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] it requires a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter] instead.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[allFrom][ColumnsSelectionDsl.allFrom]`("someColumn") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup]`(Type::myColGroup).`[allColsFrom][SingleColumn.allColsFrom]`(someColumn) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsOf][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[Int][Int]`>().`[allFrom][ColumnSet.allFrom]`(Type::someColumn) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "pathTo"["someColGroup"].`[allFrom][org.jetbrains.kotlinx.dataframe.columns.ColumnPath.allColsFrom]`("pathTo"["myColumn"]) }`
+     *
+     * #### Flavors of All (Cols):
+     *
+     * - [`all(Cols)`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allCols]`()`:
+     *     All columns
+     *
+     * - [`all(Cols)Before`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsBefore]`(column)`:
+     *     All columns before the specified column, excluding that column
+     *
+     * - [`all(Cols)After`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsAfter]`(column)`:
+     *     All columns after the specified column, excluding that column
+     *
+     * - [`all(Cols)From`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsFrom]`(column)`:
+     *     All columns from the specified column, including that column
+     *
+     * - [`all(Cols)UpTo`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsUpTo]`(column)`:
+     *     All columns up to the specified column, including that column
+     *
+     * @return A new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns from [column], including [column] itself.
+     * @see [allBefore]
+     * @see [allAfter]
+     * @see [allFrom]
+     * @see [allUpTo]
+     * @see [ColumnsSelectionDsl.allExcept]
+     * @see [all]
+     * @see [cols]
+     * @param [column] The specified column from which all columns should be taken. This column can be referenced
+     *   to both relatively to the current [ColumnsResolver][org.jetbrains.kotlinx.dataframe.columns.ColumnsResolver] and absolutely.
+     */
+    public fun ColumnPath.allColsFrom(column: ColumnPath): ColumnSet<*> = columnGroup(this).allColsFrom(column)
+
+    /** ## All (Cols) From
+     *
+     * Creates a new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] that contains a subset of columns from [this],
+     * containing all columns from [column], including [column] itself.
+     *
+     * [column] can be specified both relative to the current [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup] or the outer scope and
+     * can be referenced using any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi].
+     *
+     * If [column] does not exist, the function will return an empty [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * NOTE: Using the `{}` overloads of these functions requires a [ColumnSelector][org.jetbrains.kotlinx.dataframe.ColumnSelector]
+     * in the Plain DSL and on [column groups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     * On [ColumnSets][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] it requires a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter] instead.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[allFrom][ColumnsSelectionDsl.allFrom]`("someColumn") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup]`(Type::myColGroup).`[allColsFrom][SingleColumn.allColsFrom]`(someColumn) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsOf][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[Int][Int]`>().`[allFrom][ColumnSet.allFrom]`(Type::someColumn) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "pathTo"["someColGroup"].`[allFrom][org.jetbrains.kotlinx.dataframe.columns.ColumnPath.allColsFrom]`("myColumn") }`
+     *
+     * #### Flavors of All (Cols):
+     *
+     * - [`all(Cols)`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allCols]`()`:
+     *     All columns
+     *
+     * - [`all(Cols)Before`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsBefore]`(column)`:
+     *     All columns before the specified column, excluding that column
+     *
+     * - [`all(Cols)After`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsAfter]`(column)`:
+     *     All columns after the specified column, excluding that column
+     *
+     * - [`all(Cols)From`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsFrom]`(column)`:
+     *     All columns from the specified column, including that column
+     *
+     * - [`all(Cols)UpTo`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsUpTo]`(column)`:
+     *     All columns up to the specified column, including that column
+     *
+     * @return A new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns from [column], including [column] itself.
+     * @see [allBefore]
+     * @see [allAfter]
+     * @see [allFrom]
+     * @see [allUpTo]
+     * @see [ColumnsSelectionDsl.allExcept]
+     * @see [all]
+     * @see [cols]
+     * @param [column] The specified column from which all columns should be taken. This column can be referenced
+     *   to both relatively to the current [ColumnsResolver][org.jetbrains.kotlinx.dataframe.columns.ColumnsResolver] and absolutely.
+     */
+    public fun ColumnPath.allColsFrom(column: String): ColumnSet<*> = columnGroup(this).allColsFrom(column)
+
+    /** ## All (Cols) From
+     *
+     * Creates a new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] that contains a subset of columns from [this],
+     * containing all columns from [column], including [column] itself.
+     *
+     * [column] can be specified both relative to the current [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup] or the outer scope and
+     * can be referenced using any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi].
+     *
+     * If [column] does not exist, the function will return an empty [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * NOTE: Using the `{}` overloads of these functions requires a [ColumnSelector][org.jetbrains.kotlinx.dataframe.ColumnSelector]
+     * in the Plain DSL and on [column groups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     * On [ColumnSets][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] it requires a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter] instead.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[allFrom][ColumnsSelectionDsl.allFrom]`("someColumn") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup]`(Type::myColGroup).`[allColsFrom][SingleColumn.allColsFrom]`(someColumn) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsOf][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[Int][Int]`>().`[allFrom][ColumnSet.allFrom]`(Type::someColumn) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "pathTo"["someColGroup"].`[allFrom][org.jetbrains.kotlinx.dataframe.columns.ColumnPath.allColsFrom]`(myColumn) }`
+     *
+     * #### Flavors of All (Cols):
+     *
+     * - [`all(Cols)`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allCols]`()`:
+     *     All columns
+     *
+     * - [`all(Cols)Before`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsBefore]`(column)`:
+     *     All columns before the specified column, excluding that column
+     *
+     * - [`all(Cols)After`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsAfter]`(column)`:
+     *     All columns after the specified column, excluding that column
+     *
+     * - [`all(Cols)From`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsFrom]`(column)`:
+     *     All columns from the specified column, including that column
+     *
+     * - [`all(Cols)UpTo`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsUpTo]`(column)`:
+     *     All columns up to the specified column, including that column
+     *
+     * @return A new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns from [column], including [column] itself.
+     * @see [allBefore]
+     * @see [allAfter]
+     * @see [allFrom]
+     * @see [allUpTo]
+     * @see [ColumnsSelectionDsl.allExcept]
+     * @see [all]
+     * @see [cols]
+     * @param [column] The specified column from which all columns should be taken. This column can be referenced
+     *   to both relatively to the current [ColumnsResolver][org.jetbrains.kotlinx.dataframe.columns.ColumnsResolver] and absolutely.
+     */
+    public fun ColumnPath.allColsFrom(column: AnyColumnReference): ColumnSet<*> = columnGroup(this).allColsFrom(column)
+
+    /** ## All (Cols) From
+     *
+     * Creates a new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] that contains a subset of columns from [this],
+     * containing all columns from [column], including [column] itself.
+     *
+     * [column] can be specified both relative to the current [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup] or the outer scope and
+     * can be referenced using any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi].
+     *
+     * If [column] does not exist, the function will return an empty [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * NOTE: Using the `{}` overloads of these functions requires a [ColumnSelector][org.jetbrains.kotlinx.dataframe.ColumnSelector]
+     * in the Plain DSL and on [column groups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     * On [ColumnSets][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] it requires a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter] instead.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[allFrom][ColumnsSelectionDsl.allFrom]`("someColumn") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup]`(Type::myColGroup).`[allColsFrom][SingleColumn.allColsFrom]`(someColumn) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsOf][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[Int][Int]`>().`[allFrom][ColumnSet.allFrom]`(Type::someColumn) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "pathTo"["someColGroup"].`[allFrom][org.jetbrains.kotlinx.dataframe.columns.ColumnPath.allColsFrom]`(Type::myColumn) }`
+     *
+     * #### Flavors of All (Cols):
+     *
+     * - [`all(Cols)`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allCols]`()`:
+     *     All columns
+     *
+     * - [`all(Cols)Before`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsBefore]`(column)`:
+     *     All columns before the specified column, excluding that column
+     *
+     * - [`all(Cols)After`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsAfter]`(column)`:
+     *     All columns after the specified column, excluding that column
+     *
+     * - [`all(Cols)From`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsFrom]`(column)`:
+     *     All columns from the specified column, including that column
+     *
+     * - [`all(Cols)UpTo`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsUpTo]`(column)`:
+     *     All columns up to the specified column, including that column
+     *
+     * @return A new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns from [column], including [column] itself.
+     * @see [allBefore]
+     * @see [allAfter]
+     * @see [allFrom]
+     * @see [allUpTo]
+     * @see [ColumnsSelectionDsl.allExcept]
+     * @see [all]
+     * @see [cols]
+     * @param [column] The specified column from which all columns should be taken. This column can be referenced
+     *   to both relatively to the current [ColumnsResolver][org.jetbrains.kotlinx.dataframe.columns.ColumnsResolver] and absolutely.
+     */
+    public fun ColumnPath.allColsFrom(column: KProperty<*>): ColumnSet<*> = columnGroup(this).allColsFrom(column)
+
+    // endregion
+
+    // region allBefore
+
+    /**
+     * ## All (Cols) Before
+     *
+     * Creates a new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] that contains a subset of columns from [this],
+     * containing all columns before [column], excluding [column] itself.
+     *
+     * [column] can be specified both relative to the current [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup] or the outer scope and
+     * can be referenced using any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi].
+     *
+     * If [column] does not exist, the function will return a [ColumnSet][ColumnSet] containing all columns.
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * NOTE: Using the `{}` overloads of these functions requires a [ColumnSelector][org.jetbrains.kotlinx.dataframe.ColumnSelector]
+     * in the Plain DSL and on [column groups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     * On [ColumnSets][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] it requires a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter] instead.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[allBefore][ColumnsSelectionDsl.allBefore]`("someColumn") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup]`(Type::myColGroup).`[allColsBefore][SingleColumn.allColsBefore]`(someColumn) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsOf][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[Int][Int]`>().`[allBefore][ColumnSet.allBefore]`(Type::someColumn) }`
+     *
+     * #### Examples for this overload:
+     *
+     *
+     *
+     * #### Flavors of All (Cols):
+     *
+     * - [`all(Cols)`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allCols]`()`:
+     *     All columns
+     *
+     * - [`all(Cols)Before`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsBefore]`(column)`:
+     *     All columns before the specified column, excluding that column
+     *
+     * - [`all(Cols)After`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsAfter]`(column)`:
+     *     All columns after the specified column, excluding that column
+     *
+     * - [`all(Cols)From`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsFrom]`(column)`:
+     *     All columns from the specified column, including that column
+     *
+     * - [`all(Cols)UpTo`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsUpTo]`(column)`:
+     *     All columns up to the specified column, including that column
+     *
+     * @return A new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns before [column], excluding [column] itself.
+     * @see [allBefore]
+     * @see [allAfter]
+     * @see [allFrom]
+     * @see [allUpTo]
+     * @see [ColumnsSelectionDsl.allExcept]
+     * @see [all]
+     * @see [cols]
+     * @param [column] The specified column before which all columns should be taken. This column can be referenced
+     *   to both relatively to the current [ColumnsResolver] and absolutely.
+     */
+    private interface AllBeforeDocs
+
+    /** ## All (Cols) Before
+     *
+     * Creates a new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] that contains a subset of columns from [this],
+     * containing all columns before [column], excluding [column] itself.
+     *
+     * [column] can be specified both relative to the current [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup] or the outer scope and
+     * can be referenced using any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi].
+     *
+     * If [column] does not exist, the function will return a [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns.
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * NOTE: Using the `{}` overloads of these functions requires a [ColumnSelector][org.jetbrains.kotlinx.dataframe.ColumnSelector]
+     * in the Plain DSL and on [column groups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     * On [ColumnSets][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] it requires a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter] instead.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[allBefore][ColumnsSelectionDsl.allBefore]`("someColumn") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup]`(Type::myColGroup).`[allColsBefore][SingleColumn.allColsBefore]`(someColumn) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsOf][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[Int][Int]`>().`[allBefore][ColumnSet.allBefore]`(Type::someColumn) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]` { .. }.`[allBefore][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.allBefore]` { myColumn `[in][String.contains]` it.`[name][ColumnWithPath.name]` } }`
+     *
+     * #### Flavors of All (Cols):
+     *
+     * - [`all(Cols)`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allCols]`()`:
+     *     All columns
+     *
+     * - [`all(Cols)Before`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsBefore]`(column)`:
+     *     All columns before the specified column, excluding that column
+     *
+     * - [`all(Cols)After`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsAfter]`(column)`:
+     *     All columns after the specified column, excluding that column
+     *
+     * - [`all(Cols)From`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsFrom]`(column)`:
+     *     All columns from the specified column, including that column
+     *
+     * - [`all(Cols)UpTo`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsUpTo]`(column)`:
+     *     All columns up to the specified column, including that column
+     *
+     * @return A new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns before [column], excluding [column] itself.
+     * @see [allBefore]
+     * @see [allAfter]
+     * @see [allFrom]
+     * @see [allUpTo]
+     * @see [ColumnsSelectionDsl.allExcept]
+     * @see [all]
+     * @see [cols]
+     * @param [column] The specified column before which all columns should be taken. This column can be referenced
+     *   to both relatively to the current [ColumnsResolver][org.jetbrains.kotlinx.dataframe.columns.ColumnsResolver] and absolutely.
+     */
+    @Suppress("UNCHECKED_CAST")
+    public fun <C> ColumnSet<C>.allBefore(column: ColumnFilter<C>): ColumnSet<C> =
+        allBeforeInternal(column as ColumnFilter<*>) as ColumnSet<C>
+
+    /** ## All (Cols) Before
+     *
+     * Creates a new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] that contains a subset of columns from [this],
+     * containing all columns before [column], excluding [column] itself.
+     *
+     * [column] can be specified both relative to the current [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup] or the outer scope and
+     * can be referenced using any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi].
+     *
+     * If [column] does not exist, the function will return a [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns.
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * NOTE: Using the `{}` overloads of these functions requires a [ColumnSelector][org.jetbrains.kotlinx.dataframe.ColumnSelector]
+     * in the Plain DSL and on [column groups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     * On [ColumnSets][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] it requires a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter] instead.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[allBefore][ColumnsSelectionDsl.allBefore]`("someColumn") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup]`(Type::myColGroup).`[allColsBefore][SingleColumn.allColsBefore]`(someColumn) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsOf][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[Int][Int]`>().`[allBefore][ColumnSet.allBefore]`(Type::someColumn) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]` { .. }.`[allBefore][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.allBefore]`("pathTo"["myColumn"]) }`
+     *
+     * #### Flavors of All (Cols):
+     *
+     * - [`all(Cols)`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allCols]`()`:
+     *     All columns
+     *
+     * - [`all(Cols)Before`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsBefore]`(column)`:
+     *     All columns before the specified column, excluding that column
+     *
+     * - [`all(Cols)After`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsAfter]`(column)`:
+     *     All columns after the specified column, excluding that column
+     *
+     * - [`all(Cols)From`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsFrom]`(column)`:
+     *     All columns from the specified column, including that column
+     *
+     * - [`all(Cols)UpTo`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsUpTo]`(column)`:
+     *     All columns up to the specified column, including that column
+     *
+     * @return A new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns before [column], excluding [column] itself.
+     * @see [allBefore]
+     * @see [allAfter]
+     * @see [allFrom]
+     * @see [allUpTo]
+     * @see [ColumnsSelectionDsl.allExcept]
+     * @see [all]
+     * @see [cols]
+     * @param [column] The specified column before which all columns should be taken. This column can be referenced
+     *   to both relatively to the current [ColumnsResolver][org.jetbrains.kotlinx.dataframe.columns.ColumnsResolver] and absolutely.
+     */
+    @Suppress("UNCHECKED_CAST")
+    public fun <C> ColumnSet<C>.allBefore(column: ColumnPath): ColumnSet<C> =
+        allBeforeInternal { it.path == column } as ColumnSet<C>
+
+    /** ## All (Cols) Before
+     *
+     * Creates a new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] that contains a subset of columns from [this],
+     * containing all columns before [column], excluding [column] itself.
+     *
+     * [column] can be specified both relative to the current [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup] or the outer scope and
+     * can be referenced using any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi].
+     *
+     * If [column] does not exist, the function will return a [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns.
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * NOTE: Using the `{}` overloads of these functions requires a [ColumnSelector][org.jetbrains.kotlinx.dataframe.ColumnSelector]
+     * in the Plain DSL and on [column groups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     * On [ColumnSets][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] it requires a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter] instead.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[allBefore][ColumnsSelectionDsl.allBefore]`("someColumn") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup]`(Type::myColGroup).`[allColsBefore][SingleColumn.allColsBefore]`(someColumn) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsOf][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[Int][Int]`>().`[allBefore][ColumnSet.allBefore]`(Type::someColumn) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]` { .. }.`[allBefore][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.allBefore]`("myColumn") }`
+     *
+     * #### Flavors of All (Cols):
+     *
+     * - [`all(Cols)`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allCols]`()`:
+     *     All columns
+     *
+     * - [`all(Cols)Before`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsBefore]`(column)`:
+     *     All columns before the specified column, excluding that column
+     *
+     * - [`all(Cols)After`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsAfter]`(column)`:
+     *     All columns after the specified column, excluding that column
+     *
+     * - [`all(Cols)From`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsFrom]`(column)`:
+     *     All columns from the specified column, including that column
+     *
+     * - [`all(Cols)UpTo`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsUpTo]`(column)`:
+     *     All columns up to the specified column, including that column
+     *
+     * @return A new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns before [column], excluding [column] itself.
+     * @see [allBefore]
+     * @see [allAfter]
+     * @see [allFrom]
+     * @see [allUpTo]
+     * @see [ColumnsSelectionDsl.allExcept]
+     * @see [all]
+     * @see [cols]
+     * @param [column] The specified column before which all columns should be taken. This column can be referenced
+     *   to both relatively to the current [ColumnsResolver][org.jetbrains.kotlinx.dataframe.columns.ColumnsResolver] and absolutely.
+     */
+    public fun <C> ColumnSet<C>.allBefore(column: String): ColumnSet<C> = allBefore(pathOf(column))
+
+    /** ## All (Cols) Before
+     *
+     * Creates a new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] that contains a subset of columns from [this],
+     * containing all columns before [column], excluding [column] itself.
+     *
+     * [column] can be specified both relative to the current [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup] or the outer scope and
+     * can be referenced using any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi].
+     *
+     * If [column] does not exist, the function will return a [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns.
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * NOTE: Using the `{}` overloads of these functions requires a [ColumnSelector][org.jetbrains.kotlinx.dataframe.ColumnSelector]
+     * in the Plain DSL and on [column groups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     * On [ColumnSets][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] it requires a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter] instead.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[allBefore][ColumnsSelectionDsl.allBefore]`("someColumn") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup]`(Type::myColGroup).`[allColsBefore][SingleColumn.allColsBefore]`(someColumn) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsOf][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[Int][Int]`>().`[allBefore][ColumnSet.allBefore]`(Type::someColumn) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]` { .. }.`[allBefore][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.allBefore]`(myColumn) }`
+     *
+     * #### Flavors of All (Cols):
+     *
+     * - [`all(Cols)`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allCols]`()`:
+     *     All columns
+     *
+     * - [`all(Cols)Before`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsBefore]`(column)`:
+     *     All columns before the specified column, excluding that column
+     *
+     * - [`all(Cols)After`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsAfter]`(column)`:
+     *     All columns after the specified column, excluding that column
+     *
+     * - [`all(Cols)From`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsFrom]`(column)`:
+     *     All columns from the specified column, including that column
+     *
+     * - [`all(Cols)UpTo`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsUpTo]`(column)`:
+     *     All columns up to the specified column, including that column
+     *
+     * @return A new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns before [column], excluding [column] itself.
+     * @see [allBefore]
+     * @see [allAfter]
+     * @see [allFrom]
+     * @see [allUpTo]
+     * @see [ColumnsSelectionDsl.allExcept]
+     * @see [all]
+     * @see [cols]
+     * @param [column] The specified column before which all columns should be taken. This column can be referenced
+     *   to both relatively to the current [ColumnsResolver][org.jetbrains.kotlinx.dataframe.columns.ColumnsResolver] and absolutely.
+     */
+    public fun <C> ColumnSet<C>.allBefore(column: AnyColumnReference): ColumnSet<C> = allBefore(column.path())
+
+    /** ## All (Cols) Before
+     *
+     * Creates a new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] that contains a subset of columns from [this],
+     * containing all columns before [column], excluding [column] itself.
+     *
+     * [column] can be specified both relative to the current [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup] or the outer scope and
+     * can be referenced using any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi].
+     *
+     * If [column] does not exist, the function will return a [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns.
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * NOTE: Using the `{}` overloads of these functions requires a [ColumnSelector][org.jetbrains.kotlinx.dataframe.ColumnSelector]
+     * in the Plain DSL and on [column groups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     * On [ColumnSets][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] it requires a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter] instead.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[allBefore][ColumnsSelectionDsl.allBefore]`("someColumn") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup]`(Type::myColGroup).`[allColsBefore][SingleColumn.allColsBefore]`(someColumn) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsOf][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[Int][Int]`>().`[allBefore][ColumnSet.allBefore]`(Type::someColumn) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]` { .. }.`[allBefore][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.allBefore]`(Type::myColumn) }`
+     *
+     * #### Flavors of All (Cols):
+     *
+     * - [`all(Cols)`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allCols]`()`:
+     *     All columns
+     *
+     * - [`all(Cols)Before`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsBefore]`(column)`:
+     *     All columns before the specified column, excluding that column
+     *
+     * - [`all(Cols)After`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsAfter]`(column)`:
+     *     All columns after the specified column, excluding that column
+     *
+     * - [`all(Cols)From`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsFrom]`(column)`:
+     *     All columns from the specified column, including that column
+     *
+     * - [`all(Cols)UpTo`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsUpTo]`(column)`:
+     *     All columns up to the specified column, including that column
+     *
+     * @return A new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns before [column], excluding [column] itself.
+     * @see [allBefore]
+     * @see [allAfter]
+     * @see [allFrom]
+     * @see [allUpTo]
+     * @see [ColumnsSelectionDsl.allExcept]
+     * @see [all]
+     * @see [cols]
+     * @param [column] The specified column before which all columns should be taken. This column can be referenced
+     *   to both relatively to the current [ColumnsResolver][org.jetbrains.kotlinx.dataframe.columns.ColumnsResolver] and absolutely.
+     */
+    public fun <C> ColumnSet<C>.allBefore(column: KProperty<*>): ColumnSet<C> =
+        allBefore(column.toColumnAccessor().path())
+
+    /** ## All (Cols) Before
+     *
+     * Creates a new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] that contains a subset of columns from [this],
+     * containing all columns before [column], excluding [column] itself.
+     *
+     * [column] can be specified both relative to the current [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup] or the outer scope and
+     * can be referenced using any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi].
+     *
+     * If [column] does not exist, the function will return a [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns.
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * NOTE: Using the `{}` overloads of these functions requires a [ColumnSelector][org.jetbrains.kotlinx.dataframe.ColumnSelector]
+     * in the Plain DSL and on [column groups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     * On [ColumnSets][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] it requires a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter] instead.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[allBefore][ColumnsSelectionDsl.allBefore]`("someColumn") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup]`(Type::myColGroup).`[allColsBefore][SingleColumn.allColsBefore]`(someColumn) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsOf][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[Int][Int]`>().`[allBefore][ColumnSet.allBefore]`(Type::someColumn) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[allBefore][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.allBefore]` { myColumn } }`
+     *
+     * #### Flavors of All (Cols):
+     *
+     * - [`all(Cols)`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allCols]`()`:
+     *     All columns
+     *
+     * - [`all(Cols)Before`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsBefore]`(column)`:
+     *     All columns before the specified column, excluding that column
+     *
+     * - [`all(Cols)After`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsAfter]`(column)`:
+     *     All columns after the specified column, excluding that column
+     *
+     * - [`all(Cols)From`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsFrom]`(column)`:
+     *     All columns from the specified column, including that column
+     *
+     * - [`all(Cols)UpTo`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsUpTo]`(column)`:
+     *     All columns up to the specified column, including that column
+     *
+     * @return A new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns before [column], excluding [column] itself.
+     * @see [allBefore]
+     * @see [allAfter]
+     * @see [allFrom]
+     * @see [allUpTo]
+     * @see [ColumnsSelectionDsl.allExcept]
+     * @see [all]
+     * @see [cols]
+     * @param [column] The specified column before which all columns should be taken. This column can be referenced
+     *   to both relatively to the current [ColumnsResolver][org.jetbrains.kotlinx.dataframe.columns.ColumnsResolver] and absolutely.
+     */
+    public fun <T> ColumnsSelectionDsl<T>.allBefore(column: ColumnSelector<T, *>): ColumnSet<*> =
+        asSingleColumn().allColsBefore(column)
+
+    /** ## All (Cols) Before
+     *
+     * Creates a new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] that contains a subset of columns from [this],
+     * containing all columns before [column], excluding [column] itself.
+     *
+     * [column] can be specified both relative to the current [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup] or the outer scope and
+     * can be referenced using any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi].
+     *
+     * If [column] does not exist, the function will return a [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns.
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * NOTE: Using the `{}` overloads of these functions requires a [ColumnSelector][org.jetbrains.kotlinx.dataframe.ColumnSelector]
+     * in the Plain DSL and on [column groups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     * On [ColumnSets][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] it requires a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter] instead.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[allBefore][ColumnsSelectionDsl.allBefore]`("someColumn") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup]`(Type::myColGroup).`[allColsBefore][SingleColumn.allColsBefore]`(someColumn) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsOf][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[Int][Int]`>().`[allBefore][ColumnSet.allBefore]`(Type::someColumn) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[allBefore][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.allBefore]`("pathTo"["myColumn"]) }`
+     *
+     * #### Flavors of All (Cols):
+     *
+     * - [`all(Cols)`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allCols]`()`:
+     *     All columns
+     *
+     * - [`all(Cols)Before`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsBefore]`(column)`:
+     *     All columns before the specified column, excluding that column
+     *
+     * - [`all(Cols)After`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsAfter]`(column)`:
+     *     All columns after the specified column, excluding that column
+     *
+     * - [`all(Cols)From`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsFrom]`(column)`:
+     *     All columns from the specified column, including that column
+     *
+     * - [`all(Cols)UpTo`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsUpTo]`(column)`:
+     *     All columns up to the specified column, including that column
+     *
+     * @return A new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns before [column], excluding [column] itself.
+     * @see [allBefore]
+     * @see [allAfter]
+     * @see [allFrom]
+     * @see [allUpTo]
+     * @see [ColumnsSelectionDsl.allExcept]
+     * @see [all]
+     * @see [cols]
+     * @param [column] The specified column before which all columns should be taken. This column can be referenced
+     *   to both relatively to the current [ColumnsResolver][org.jetbrains.kotlinx.dataframe.columns.ColumnsResolver] and absolutely.
+     */
+    public fun ColumnsSelectionDsl<*>.allBefore(column: ColumnPath): ColumnSet<*> =
+        asSingleColumn().allColsBefore(column)
+
+    /** ## All (Cols) Before
+     *
+     * Creates a new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] that contains a subset of columns from [this],
+     * containing all columns before [column], excluding [column] itself.
+     *
+     * [column] can be specified both relative to the current [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup] or the outer scope and
+     * can be referenced using any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi].
+     *
+     * If [column] does not exist, the function will return a [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns.
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * NOTE: Using the `{}` overloads of these functions requires a [ColumnSelector][org.jetbrains.kotlinx.dataframe.ColumnSelector]
+     * in the Plain DSL and on [column groups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     * On [ColumnSets][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] it requires a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter] instead.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[allBefore][ColumnsSelectionDsl.allBefore]`("someColumn") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup]`(Type::myColGroup).`[allColsBefore][SingleColumn.allColsBefore]`(someColumn) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsOf][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[Int][Int]`>().`[allBefore][ColumnSet.allBefore]`(Type::someColumn) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[allBefore][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.allBefore]`("myColumn") }`
+     *
+     * #### Flavors of All (Cols):
+     *
+     * - [`all(Cols)`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allCols]`()`:
+     *     All columns
+     *
+     * - [`all(Cols)Before`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsBefore]`(column)`:
+     *     All columns before the specified column, excluding that column
+     *
+     * - [`all(Cols)After`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsAfter]`(column)`:
+     *     All columns after the specified column, excluding that column
+     *
+     * - [`all(Cols)From`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsFrom]`(column)`:
+     *     All columns from the specified column, including that column
+     *
+     * - [`all(Cols)UpTo`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsUpTo]`(column)`:
+     *     All columns up to the specified column, including that column
+     *
+     * @return A new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns before [column], excluding [column] itself.
+     * @see [allBefore]
+     * @see [allAfter]
+     * @see [allFrom]
+     * @see [allUpTo]
+     * @see [ColumnsSelectionDsl.allExcept]
+     * @see [all]
+     * @see [cols]
+     * @param [column] The specified column before which all columns should be taken. This column can be referenced
+     *   to both relatively to the current [ColumnsResolver][org.jetbrains.kotlinx.dataframe.columns.ColumnsResolver] and absolutely.
+     */
+    public fun ColumnsSelectionDsl<*>.allBefore(column: String): ColumnSet<*> = allBefore(pathOf(column))
+
+    /** ## All (Cols) Before
+     *
+     * Creates a new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] that contains a subset of columns from [this],
+     * containing all columns before [column], excluding [column] itself.
+     *
+     * [column] can be specified both relative to the current [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup] or the outer scope and
+     * can be referenced using any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi].
+     *
+     * If [column] does not exist, the function will return a [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns.
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * NOTE: Using the `{}` overloads of these functions requires a [ColumnSelector][org.jetbrains.kotlinx.dataframe.ColumnSelector]
+     * in the Plain DSL and on [column groups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     * On [ColumnSets][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] it requires a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter] instead.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[allBefore][ColumnsSelectionDsl.allBefore]`("someColumn") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup]`(Type::myColGroup).`[allColsBefore][SingleColumn.allColsBefore]`(someColumn) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsOf][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[Int][Int]`>().`[allBefore][ColumnSet.allBefore]`(Type::someColumn) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[allBefore][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.allBefore]`(myColumn) }`
+     *
+     * #### Flavors of All (Cols):
+     *
+     * - [`all(Cols)`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allCols]`()`:
+     *     All columns
+     *
+     * - [`all(Cols)Before`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsBefore]`(column)`:
+     *     All columns before the specified column, excluding that column
+     *
+     * - [`all(Cols)After`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsAfter]`(column)`:
+     *     All columns after the specified column, excluding that column
+     *
+     * - [`all(Cols)From`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsFrom]`(column)`:
+     *     All columns from the specified column, including that column
+     *
+     * - [`all(Cols)UpTo`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsUpTo]`(column)`:
+     *     All columns up to the specified column, including that column
+     *
+     * @return A new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns before [column], excluding [column] itself.
+     * @see [allBefore]
+     * @see [allAfter]
+     * @see [allFrom]
+     * @see [allUpTo]
+     * @see [ColumnsSelectionDsl.allExcept]
+     * @see [all]
+     * @see [cols]
+     * @param [column] The specified column before which all columns should be taken. This column can be referenced
+     *   to both relatively to the current [ColumnsResolver][org.jetbrains.kotlinx.dataframe.columns.ColumnsResolver] and absolutely.
+     */
+    public fun ColumnsSelectionDsl<*>.allBefore(column: AnyColumnReference): ColumnSet<*> = allBefore(column.path())
+
+    /** ## All (Cols) Before
+     *
+     * Creates a new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] that contains a subset of columns from [this],
+     * containing all columns before [column], excluding [column] itself.
+     *
+     * [column] can be specified both relative to the current [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup] or the outer scope and
+     * can be referenced using any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi].
+     *
+     * If [column] does not exist, the function will return a [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns.
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * NOTE: Using the `{}` overloads of these functions requires a [ColumnSelector][org.jetbrains.kotlinx.dataframe.ColumnSelector]
+     * in the Plain DSL and on [column groups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     * On [ColumnSets][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] it requires a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter] instead.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[allBefore][ColumnsSelectionDsl.allBefore]`("someColumn") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup]`(Type::myColGroup).`[allColsBefore][SingleColumn.allColsBefore]`(someColumn) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsOf][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[Int][Int]`>().`[allBefore][ColumnSet.allBefore]`(Type::someColumn) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[allBefore][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.allBefore]`(Type::myColumn) }`
+     *
+     * #### Flavors of All (Cols):
+     *
+     * - [`all(Cols)`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allCols]`()`:
+     *     All columns
+     *
+     * - [`all(Cols)Before`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsBefore]`(column)`:
+     *     All columns before the specified column, excluding that column
+     *
+     * - [`all(Cols)After`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsAfter]`(column)`:
+     *     All columns after the specified column, excluding that column
+     *
+     * - [`all(Cols)From`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsFrom]`(column)`:
+     *     All columns from the specified column, including that column
+     *
+     * - [`all(Cols)UpTo`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsUpTo]`(column)`:
+     *     All columns up to the specified column, including that column
+     *
+     * @return A new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns before [column], excluding [column] itself.
+     * @see [allBefore]
+     * @see [allAfter]
+     * @see [allFrom]
+     * @see [allUpTo]
+     * @see [ColumnsSelectionDsl.allExcept]
+     * @see [all]
+     * @see [cols]
+     * @param [column] The specified column before which all columns should be taken. This column can be referenced
+     *   to both relatively to the current [ColumnsResolver][org.jetbrains.kotlinx.dataframe.columns.ColumnsResolver] and absolutely.
+     */
+    public fun ColumnsSelectionDsl<*>.allBefore(column: KProperty<*>): ColumnSet<*> =
+        allBefore(column.toColumnAccessor().path())
+
+    /** ## All (Cols) Before
+     *
+     * Creates a new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] that contains a subset of columns from [this],
+     * containing all columns before [column], excluding [column] itself.
+     *
+     * [column] can be specified both relative to the current [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup] or the outer scope and
+     * can be referenced using any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi].
+     *
+     * If [column] does not exist, the function will return a [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns.
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * NOTE: Using the `{}` overloads of these functions requires a [ColumnSelector][org.jetbrains.kotlinx.dataframe.ColumnSelector]
+     * in the Plain DSL and on [column groups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     * On [ColumnSets][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] it requires a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter] instead.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[allBefore][ColumnsSelectionDsl.allBefore]`("someColumn") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup]`(Type::myColGroup).`[allColsBefore][SingleColumn.allColsBefore]`(someColumn) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsOf][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[Int][Int]`>().`[allBefore][ColumnSet.allBefore]`(Type::someColumn) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { someColumnGroup.`[allColsBefore][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.allColsBefore]` { myColumn } }`
+     *
+     * #### Flavors of All (Cols):
+     *
+     * - [`all(Cols)`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allCols]`()`:
+     *     All columns
+     *
+     * - [`all(Cols)Before`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsBefore]`(column)`:
+     *     All columns before the specified column, excluding that column
+     *
+     * - [`all(Cols)After`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsAfter]`(column)`:
+     *     All columns after the specified column, excluding that column
+     *
+     * - [`all(Cols)From`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsFrom]`(column)`:
+     *     All columns from the specified column, including that column
+     *
+     * - [`all(Cols)UpTo`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsUpTo]`(column)`:
+     *     All columns up to the specified column, including that column
+     *
+     * @return A new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns before [column], excluding [column] itself.
+     * @see [allBefore]
+     * @see [allAfter]
+     * @see [allFrom]
+     * @see [allUpTo]
+     * @see [ColumnsSelectionDsl.allExcept]
+     * @see [all]
+     * @see [cols]
+     * @param [column] The specified column before which all columns should be taken. This column can be referenced
+     *   to both relatively to the current [ColumnsResolver][org.jetbrains.kotlinx.dataframe.columns.ColumnsResolver] and absolutely.
+     */
+    public fun <T> SingleColumn<DataRow<T>>.allColsBefore(column: ColumnSelector<T, *>): ColumnSet<*> {
+        var resolvedCol: DataColumn<*>? = null
+        return this
+            .ensureIsColumnGroup()
+            .onResolve { resolvedCol = it!!.asColumnGroup().getColumn(column) }
+            .allBeforeInternal { it.data == resolvedCol }
+    }
+
+    /** ## All (Cols) Before
+     *
+     * Creates a new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] that contains a subset of columns from [this],
+     * containing all columns before [column], excluding [column] itself.
+     *
+     * [column] can be specified both relative to the current [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup] or the outer scope and
+     * can be referenced using any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi].
+     *
+     * If [column] does not exist, the function will return a [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns.
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * NOTE: Using the `{}` overloads of these functions requires a [ColumnSelector][org.jetbrains.kotlinx.dataframe.ColumnSelector]
+     * in the Plain DSL and on [column groups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     * On [ColumnSets][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] it requires a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter] instead.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[allBefore][ColumnsSelectionDsl.allBefore]`("someColumn") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup]`(Type::myColGroup).`[allColsBefore][SingleColumn.allColsBefore]`(someColumn) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsOf][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[Int][Int]`>().`[allBefore][ColumnSet.allBefore]`(Type::someColumn) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { someColumnGroup.`[allColsBefore][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.allColsBefore]`("pathTo"["myColumn"]) }`
+     *
+     * #### Flavors of All (Cols):
+     *
+     * - [`all(Cols)`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allCols]`()`:
+     *     All columns
+     *
+     * - [`all(Cols)Before`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsBefore]`(column)`:
+     *     All columns before the specified column, excluding that column
+     *
+     * - [`all(Cols)After`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsAfter]`(column)`:
+     *     All columns after the specified column, excluding that column
+     *
+     * - [`all(Cols)From`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsFrom]`(column)`:
+     *     All columns from the specified column, including that column
+     *
+     * - [`all(Cols)UpTo`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsUpTo]`(column)`:
+     *     All columns up to the specified column, including that column
+     *
+     * @return A new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns before [column], excluding [column] itself.
+     * @see [allBefore]
+     * @see [allAfter]
+     * @see [allFrom]
+     * @see [allUpTo]
+     * @see [ColumnsSelectionDsl.allExcept]
+     * @see [all]
+     * @see [cols]
+     * @param [column] The specified column before which all columns should be taken. This column can be referenced
+     *   to both relatively to the current [ColumnsResolver][org.jetbrains.kotlinx.dataframe.columns.ColumnsResolver] and absolutely.
+     */
+    public fun SingleColumn<DataRow<*>>.allColsBefore(column: ColumnPath): ColumnSet<*> {
+        var path: ColumnPath? = null
+        return this
+            .ensureIsColumnGroup()
+            .onResolve { path = it!!.path }
+            .allBeforeInternal { it.path == path!! + column || it.path == column }
+    }
+
+    /** ## All (Cols) Before
+     *
+     * Creates a new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] that contains a subset of columns from [this],
+     * containing all columns before [column], excluding [column] itself.
+     *
+     * [column] can be specified both relative to the current [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup] or the outer scope and
+     * can be referenced using any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi].
+     *
+     * If [column] does not exist, the function will return a [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns.
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * NOTE: Using the `{}` overloads of these functions requires a [ColumnSelector][org.jetbrains.kotlinx.dataframe.ColumnSelector]
+     * in the Plain DSL and on [column groups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     * On [ColumnSets][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] it requires a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter] instead.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[allBefore][ColumnsSelectionDsl.allBefore]`("someColumn") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup]`(Type::myColGroup).`[allColsBefore][SingleColumn.allColsBefore]`(someColumn) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsOf][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[Int][Int]`>().`[allBefore][ColumnSet.allBefore]`(Type::someColumn) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { someColumnGroup.`[allColsBefore][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.allColsBefore]`("myColumn") }`
+     *
+     * #### Flavors of All (Cols):
+     *
+     * - [`all(Cols)`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allCols]`()`:
+     *     All columns
+     *
+     * - [`all(Cols)Before`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsBefore]`(column)`:
+     *     All columns before the specified column, excluding that column
+     *
+     * - [`all(Cols)After`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsAfter]`(column)`:
+     *     All columns after the specified column, excluding that column
+     *
+     * - [`all(Cols)From`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsFrom]`(column)`:
+     *     All columns from the specified column, including that column
+     *
+     * - [`all(Cols)UpTo`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsUpTo]`(column)`:
+     *     All columns up to the specified column, including that column
+     *
+     * @return A new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns before [column], excluding [column] itself.
+     * @see [allBefore]
+     * @see [allAfter]
+     * @see [allFrom]
+     * @see [allUpTo]
+     * @see [ColumnsSelectionDsl.allExcept]
+     * @see [all]
+     * @see [cols]
+     * @param [column] The specified column before which all columns should be taken. This column can be referenced
+     *   to both relatively to the current [ColumnsResolver][org.jetbrains.kotlinx.dataframe.columns.ColumnsResolver] and absolutely.
+     */
+    public fun SingleColumn<DataRow<*>>.allColsBefore(column: String): ColumnSet<*> = allColsBefore(pathOf(column))
+
+    /** ## All (Cols) Before
+     *
+     * Creates a new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] that contains a subset of columns from [this],
+     * containing all columns before [column], excluding [column] itself.
+     *
+     * [column] can be specified both relative to the current [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup] or the outer scope and
+     * can be referenced using any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi].
+     *
+     * If [column] does not exist, the function will return a [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns.
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * NOTE: Using the `{}` overloads of these functions requires a [ColumnSelector][org.jetbrains.kotlinx.dataframe.ColumnSelector]
+     * in the Plain DSL and on [column groups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     * On [ColumnSets][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] it requires a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter] instead.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[allBefore][ColumnsSelectionDsl.allBefore]`("someColumn") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup]`(Type::myColGroup).`[allColsBefore][SingleColumn.allColsBefore]`(someColumn) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsOf][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[Int][Int]`>().`[allBefore][ColumnSet.allBefore]`(Type::someColumn) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { someColumnGroup.`[allColsBefore][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.allColsBefore]`(myColumn) }`
+     *
+     * #### Flavors of All (Cols):
+     *
+     * - [`all(Cols)`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allCols]`()`:
+     *     All columns
+     *
+     * - [`all(Cols)Before`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsBefore]`(column)`:
+     *     All columns before the specified column, excluding that column
+     *
+     * - [`all(Cols)After`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsAfter]`(column)`:
+     *     All columns after the specified column, excluding that column
+     *
+     * - [`all(Cols)From`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsFrom]`(column)`:
+     *     All columns from the specified column, including that column
+     *
+     * - [`all(Cols)UpTo`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsUpTo]`(column)`:
+     *     All columns up to the specified column, including that column
+     *
+     * @return A new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns before [column], excluding [column] itself.
+     * @see [allBefore]
+     * @see [allAfter]
+     * @see [allFrom]
+     * @see [allUpTo]
+     * @see [ColumnsSelectionDsl.allExcept]
+     * @see [all]
+     * @see [cols]
+     * @param [column] The specified column before which all columns should be taken. This column can be referenced
+     *   to both relatively to the current [ColumnsResolver][org.jetbrains.kotlinx.dataframe.columns.ColumnsResolver] and absolutely.
+     */
+    public fun SingleColumn<DataRow<*>>.allColsBefore(column: AnyColumnReference): ColumnSet<*> =
+        allColsBefore(column.path())
+
+    /** ## All (Cols) Before
+     *
+     * Creates a new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] that contains a subset of columns from [this],
+     * containing all columns before [column], excluding [column] itself.
+     *
+     * [column] can be specified both relative to the current [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup] or the outer scope and
+     * can be referenced using any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi].
+     *
+     * If [column] does not exist, the function will return a [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns.
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * NOTE: Using the `{}` overloads of these functions requires a [ColumnSelector][org.jetbrains.kotlinx.dataframe.ColumnSelector]
+     * in the Plain DSL and on [column groups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     * On [ColumnSets][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] it requires a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter] instead.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[allBefore][ColumnsSelectionDsl.allBefore]`("someColumn") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup]`(Type::myColGroup).`[allColsBefore][SingleColumn.allColsBefore]`(someColumn) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsOf][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[Int][Int]`>().`[allBefore][ColumnSet.allBefore]`(Type::someColumn) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { someColumnGroup.`[allColsBefore][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.allColsBefore]`(Type::myColumn) }`
+     *
+     * #### Flavors of All (Cols):
+     *
+     * - [`all(Cols)`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allCols]`()`:
+     *     All columns
+     *
+     * - [`all(Cols)Before`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsBefore]`(column)`:
+     *     All columns before the specified column, excluding that column
+     *
+     * - [`all(Cols)After`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsAfter]`(column)`:
+     *     All columns after the specified column, excluding that column
+     *
+     * - [`all(Cols)From`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsFrom]`(column)`:
+     *     All columns from the specified column, including that column
+     *
+     * - [`all(Cols)UpTo`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsUpTo]`(column)`:
+     *     All columns up to the specified column, including that column
+     *
+     * @return A new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns before [column], excluding [column] itself.
+     * @see [allBefore]
+     * @see [allAfter]
+     * @see [allFrom]
+     * @see [allUpTo]
+     * @see [ColumnsSelectionDsl.allExcept]
+     * @see [all]
+     * @see [cols]
+     * @param [column] The specified column before which all columns should be taken. This column can be referenced
+     *   to both relatively to the current [ColumnsResolver][org.jetbrains.kotlinx.dataframe.columns.ColumnsResolver] and absolutely.
+     */
+    public fun SingleColumn<DataRow<*>>.allColsBefore(column: KProperty<*>): ColumnSet<*> =
+        allColsBefore(column.toColumnAccessor().path())
+
+    /** ## All (Cols) Before
+     *
+     * Creates a new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] that contains a subset of columns from [this],
+     * containing all columns before [column], excluding [column] itself.
+     *
+     * [column] can be specified both relative to the current [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup] or the outer scope and
+     * can be referenced using any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi].
+     *
+     * If [column] does not exist, the function will return a [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns.
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * NOTE: Using the `{}` overloads of these functions requires a [ColumnSelector][org.jetbrains.kotlinx.dataframe.ColumnSelector]
+     * in the Plain DSL and on [column groups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     * On [ColumnSets][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] it requires a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter] instead.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[allBefore][ColumnsSelectionDsl.allBefore]`("someColumn") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup]`(Type::myColGroup).`[allColsBefore][SingleColumn.allColsBefore]`(someColumn) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsOf][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[Int][Int]`>().`[allBefore][ColumnSet.allBefore]`(Type::someColumn) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "someColGroup".`[allColsBefore][kotlin.String.allColsBefore]` { myColumn } }`
+     *
+     * #### Flavors of All (Cols):
+     *
+     * - [`all(Cols)`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allCols]`()`:
+     *     All columns
+     *
+     * - [`all(Cols)Before`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsBefore]`(column)`:
+     *     All columns before the specified column, excluding that column
+     *
+     * - [`all(Cols)After`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsAfter]`(column)`:
+     *     All columns after the specified column, excluding that column
+     *
+     * - [`all(Cols)From`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsFrom]`(column)`:
+     *     All columns from the specified column, including that column
+     *
+     * - [`all(Cols)UpTo`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsUpTo]`(column)`:
+     *     All columns up to the specified column, including that column
+     *
+     * @return A new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns before [column], excluding [column] itself.
+     * @see [allBefore]
+     * @see [allAfter]
+     * @see [allFrom]
+     * @see [allUpTo]
+     * @see [ColumnsSelectionDsl.allExcept]
+     * @see [all]
+     * @see [cols]
+     * @param [column] The specified column before which all columns should be taken. This column can be referenced
+     *   to both relatively to the current [ColumnsResolver][org.jetbrains.kotlinx.dataframe.columns.ColumnsResolver] and absolutely.
+     */
+    public fun String.allColsBefore(column: ColumnSelector<*, *>): ColumnSet<*> =
+        columnGroup(this).allColsBefore(column)
+
+    /** ## All (Cols) Before
+     *
+     * Creates a new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] that contains a subset of columns from [this],
+     * containing all columns before [column], excluding [column] itself.
+     *
+     * [column] can be specified both relative to the current [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup] or the outer scope and
+     * can be referenced using any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi].
+     *
+     * If [column] does not exist, the function will return a [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns.
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * NOTE: Using the `{}` overloads of these functions requires a [ColumnSelector][org.jetbrains.kotlinx.dataframe.ColumnSelector]
+     * in the Plain DSL and on [column groups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     * On [ColumnSets][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] it requires a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter] instead.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[allBefore][ColumnsSelectionDsl.allBefore]`("someColumn") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup]`(Type::myColGroup).`[allColsBefore][SingleColumn.allColsBefore]`(someColumn) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsOf][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[Int][Int]`>().`[allBefore][ColumnSet.allBefore]`(Type::someColumn) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "someColGroup".`[allColsBefore][kotlin.String.allColsBefore]`("pathTo"["myColumn"]) }`
+     *
+     * #### Flavors of All (Cols):
+     *
+     * - [`all(Cols)`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allCols]`()`:
+     *     All columns
+     *
+     * - [`all(Cols)Before`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsBefore]`(column)`:
+     *     All columns before the specified column, excluding that column
+     *
+     * - [`all(Cols)After`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsAfter]`(column)`:
+     *     All columns after the specified column, excluding that column
+     *
+     * - [`all(Cols)From`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsFrom]`(column)`:
+     *     All columns from the specified column, including that column
+     *
+     * - [`all(Cols)UpTo`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsUpTo]`(column)`:
+     *     All columns up to the specified column, including that column
+     *
+     * @return A new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns before [column], excluding [column] itself.
+     * @see [allBefore]
+     * @see [allAfter]
+     * @see [allFrom]
+     * @see [allUpTo]
+     * @see [ColumnsSelectionDsl.allExcept]
+     * @see [all]
+     * @see [cols]
+     * @param [column] The specified column before which all columns should be taken. This column can be referenced
+     *   to both relatively to the current [ColumnsResolver][org.jetbrains.kotlinx.dataframe.columns.ColumnsResolver] and absolutely.
+     */
+    public fun String.allColsBefore(column: ColumnPath): ColumnSet<*> = columnGroup(this).allColsBefore(column)
+
+    /** ## All (Cols) Before
+     *
+     * Creates a new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] that contains a subset of columns from [this],
+     * containing all columns before [column], excluding [column] itself.
+     *
+     * [column] can be specified both relative to the current [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup] or the outer scope and
+     * can be referenced using any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi].
+     *
+     * If [column] does not exist, the function will return a [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns.
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * NOTE: Using the `{}` overloads of these functions requires a [ColumnSelector][org.jetbrains.kotlinx.dataframe.ColumnSelector]
+     * in the Plain DSL and on [column groups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     * On [ColumnSets][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] it requires a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter] instead.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[allBefore][ColumnsSelectionDsl.allBefore]`("someColumn") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup]`(Type::myColGroup).`[allColsBefore][SingleColumn.allColsBefore]`(someColumn) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsOf][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[Int][Int]`>().`[allBefore][ColumnSet.allBefore]`(Type::someColumn) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "someColGroup".`[allColsBefore][kotlin.String.allColsBefore]`("myColumn") }`
+     *
+     * #### Flavors of All (Cols):
+     *
+     * - [`all(Cols)`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allCols]`()`:
+     *     All columns
+     *
+     * - [`all(Cols)Before`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsBefore]`(column)`:
+     *     All columns before the specified column, excluding that column
+     *
+     * - [`all(Cols)After`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsAfter]`(column)`:
+     *     All columns after the specified column, excluding that column
+     *
+     * - [`all(Cols)From`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsFrom]`(column)`:
+     *     All columns from the specified column, including that column
+     *
+     * - [`all(Cols)UpTo`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsUpTo]`(column)`:
+     *     All columns up to the specified column, including that column
+     *
+     * @return A new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns before [column], excluding [column] itself.
+     * @see [allBefore]
+     * @see [allAfter]
+     * @see [allFrom]
+     * @see [allUpTo]
+     * @see [ColumnsSelectionDsl.allExcept]
+     * @see [all]
+     * @see [cols]
+     * @param [column] The specified column before which all columns should be taken. This column can be referenced
+     *   to both relatively to the current [ColumnsResolver][org.jetbrains.kotlinx.dataframe.columns.ColumnsResolver] and absolutely.
+     */
+    public fun String.allColsBefore(column: String): ColumnSet<*> = columnGroup(this).allColsBefore(column)
+
+    /** ## All (Cols) Before
+     *
+     * Creates a new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] that contains a subset of columns from [this],
+     * containing all columns before [column], excluding [column] itself.
+     *
+     * [column] can be specified both relative to the current [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup] or the outer scope and
+     * can be referenced using any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi].
+     *
+     * If [column] does not exist, the function will return a [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns.
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * NOTE: Using the `{}` overloads of these functions requires a [ColumnSelector][org.jetbrains.kotlinx.dataframe.ColumnSelector]
+     * in the Plain DSL and on [column groups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     * On [ColumnSets][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] it requires a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter] instead.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[allBefore][ColumnsSelectionDsl.allBefore]`("someColumn") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup]`(Type::myColGroup).`[allColsBefore][SingleColumn.allColsBefore]`(someColumn) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsOf][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[Int][Int]`>().`[allBefore][ColumnSet.allBefore]`(Type::someColumn) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "someColGroup".`[allColsBefore][kotlin.String.allColsBefore]`(myColumn) }`
+     *
+     * #### Flavors of All (Cols):
+     *
+     * - [`all(Cols)`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allCols]`()`:
+     *     All columns
+     *
+     * - [`all(Cols)Before`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsBefore]`(column)`:
+     *     All columns before the specified column, excluding that column
+     *
+     * - [`all(Cols)After`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsAfter]`(column)`:
+     *     All columns after the specified column, excluding that column
+     *
+     * - [`all(Cols)From`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsFrom]`(column)`:
+     *     All columns from the specified column, including that column
+     *
+     * - [`all(Cols)UpTo`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsUpTo]`(column)`:
+     *     All columns up to the specified column, including that column
+     *
+     * @return A new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns before [column], excluding [column] itself.
+     * @see [allBefore]
+     * @see [allAfter]
+     * @see [allFrom]
+     * @see [allUpTo]
+     * @see [ColumnsSelectionDsl.allExcept]
+     * @see [all]
+     * @see [cols]
+     * @param [column] The specified column before which all columns should be taken. This column can be referenced
+     *   to both relatively to the current [ColumnsResolver][org.jetbrains.kotlinx.dataframe.columns.ColumnsResolver] and absolutely.
+     */
+    public fun String.allColsBefore(column: AnyColumnReference): ColumnSet<*> = columnGroup(this).allColsBefore(column)
+
+    /** ## All (Cols) Before
+     *
+     * Creates a new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] that contains a subset of columns from [this],
+     * containing all columns before [column], excluding [column] itself.
+     *
+     * [column] can be specified both relative to the current [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup] or the outer scope and
+     * can be referenced using any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi].
+     *
+     * If [column] does not exist, the function will return a [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns.
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * NOTE: Using the `{}` overloads of these functions requires a [ColumnSelector][org.jetbrains.kotlinx.dataframe.ColumnSelector]
+     * in the Plain DSL and on [column groups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     * On [ColumnSets][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] it requires a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter] instead.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[allBefore][ColumnsSelectionDsl.allBefore]`("someColumn") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup]`(Type::myColGroup).`[allColsBefore][SingleColumn.allColsBefore]`(someColumn) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsOf][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[Int][Int]`>().`[allBefore][ColumnSet.allBefore]`(Type::someColumn) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "someColGroup".`[allColsBefore][kotlin.String.allColsBefore]`(Type::myColumn) }`
+     *
+     * #### Flavors of All (Cols):
+     *
+     * - [`all(Cols)`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allCols]`()`:
+     *     All columns
+     *
+     * - [`all(Cols)Before`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsBefore]`(column)`:
+     *     All columns before the specified column, excluding that column
+     *
+     * - [`all(Cols)After`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsAfter]`(column)`:
+     *     All columns after the specified column, excluding that column
+     *
+     * - [`all(Cols)From`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsFrom]`(column)`:
+     *     All columns from the specified column, including that column
+     *
+     * - [`all(Cols)UpTo`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsUpTo]`(column)`:
+     *     All columns up to the specified column, including that column
+     *
+     * @return A new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns before [column], excluding [column] itself.
+     * @see [allBefore]
+     * @see [allAfter]
+     * @see [allFrom]
+     * @see [allUpTo]
+     * @see [ColumnsSelectionDsl.allExcept]
+     * @see [all]
+     * @see [cols]
+     * @param [column] The specified column before which all columns should be taken. This column can be referenced
+     *   to both relatively to the current [ColumnsResolver][org.jetbrains.kotlinx.dataframe.columns.ColumnsResolver] and absolutely.
+     */
+    public fun String.allColsBefore(column: KProperty<*>): ColumnSet<*> = columnGroup(this).allColsBefore(column)
+
+    /**
+     * ## All (Cols) Before
+     *
+     * Creates a new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] that contains a subset of columns from [this],
+     * containing all columns before [column], excluding [column] itself.
+     *
+     * [column] can be specified both relative to the current [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup] or the outer scope and
+     * can be referenced using any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi].
+     *
+     * If [column] does not exist, the function will return a [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns.
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * NOTE: Using the `{}` overloads of these functions requires a [ColumnSelector][org.jetbrains.kotlinx.dataframe.ColumnSelector]
+     * in the Plain DSL and on [column groups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     * On [ColumnSets][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] it requires a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter] instead.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[allBefore][ColumnsSelectionDsl.allBefore]`("someColumn") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup]`(Type::myColGroup).`[allColsBefore][SingleColumn.allColsBefore]`(someColumn) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsOf][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[Int][Int]`>().`[allBefore][ColumnSet.allBefore]`(Type::someColumn) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { DataSchemaType::someColGroup.`[allColsBefore][kotlin.reflect.KProperty.allColsBefore]` { myColumn } }`
+     *
+     * #### Flavors of All (Cols):
+     *
+     * - [`all(Cols)`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allCols]`()`:
+     *     All columns
+     *
+     * - [`all(Cols)Before`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsBefore]`(column)`:
+     *     All columns before the specified column, excluding that column
+     *
+     * - [`all(Cols)After`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsAfter]`(column)`:
+     *     All columns after the specified column, excluding that column
+     *
+     * - [`all(Cols)From`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsFrom]`(column)`:
+     *     All columns from the specified column, including that column
+     *
+     * - [`all(Cols)UpTo`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsUpTo]`(column)`:
+     *     All columns up to the specified column, including that column
+     *
+     * @return A new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns before [column], excluding [column] itself.
+     * @see [allBefore]
+     * @see [allAfter]
+     * @see [allFrom]
+     * @see [allUpTo]
+     * @see [ColumnsSelectionDsl.allExcept]
+     * @see [all]
+     * @see [cols]
+     * @param [column] The specified column before which all columns should be taken. This column can be referenced
+     *   to both relatively to the current [ColumnsResolver][org.jetbrains.kotlinx.dataframe.columns.ColumnsResolver] and absolutely.
+     */
+    public fun <C> KProperty<C>.allColsBefore(column: ColumnSelector<C, *>): ColumnSet<*> =
+        columnGroup(this).allColsBefore(column)
+
+    /** ## All (Cols) Before
+     *
+     * Creates a new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] that contains a subset of columns from [this],
+     * containing all columns before [column], excluding [column] itself.
+     *
+     * [column] can be specified both relative to the current [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup] or the outer scope and
+     * can be referenced using any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi].
+     *
+     * If [column] does not exist, the function will return a [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns.
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * NOTE: Using the `{}` overloads of these functions requires a [ColumnSelector][org.jetbrains.kotlinx.dataframe.ColumnSelector]
+     * in the Plain DSL and on [column groups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     * On [ColumnSets][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] it requires a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter] instead.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[allBefore][ColumnsSelectionDsl.allBefore]`("someColumn") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup]`(Type::myColGroup).`[allColsBefore][SingleColumn.allColsBefore]`(someColumn) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsOf][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[Int][Int]`>().`[allBefore][ColumnSet.allBefore]`(Type::someColumn) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { DataSchemaType::someColGroup.`[allColsBefore][kotlin.reflect.KProperty.allColsBefore]`("pathTo"["myColumn"]) }`
+     *
+     * #### Flavors of All (Cols):
+     *
+     * - [`all(Cols)`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allCols]`()`:
+     *     All columns
+     *
+     * - [`all(Cols)Before`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsBefore]`(column)`:
+     *     All columns before the specified column, excluding that column
+     *
+     * - [`all(Cols)After`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsAfter]`(column)`:
+     *     All columns after the specified column, excluding that column
+     *
+     * - [`all(Cols)From`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsFrom]`(column)`:
+     *     All columns from the specified column, including that column
+     *
+     * - [`all(Cols)UpTo`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsUpTo]`(column)`:
+     *     All columns up to the specified column, including that column
+     *
+     * @return A new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns before [column], excluding [column] itself.
+     * @see [allBefore]
+     * @see [allAfter]
+     * @see [allFrom]
+     * @see [allUpTo]
+     * @see [ColumnsSelectionDsl.allExcept]
+     * @see [all]
+     * @see [cols]
+     * @param [column] The specified column before which all columns should be taken. This column can be referenced
+     *   to both relatively to the current [ColumnsResolver][org.jetbrains.kotlinx.dataframe.columns.ColumnsResolver] and absolutely.
+     */
+    public fun KProperty<*>.allColsBefore(column: ColumnPath): ColumnSet<*> = columnGroup(this).allColsBefore(column)
+
+    /** ## All (Cols) Before
+     *
+     * Creates a new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] that contains a subset of columns from [this],
+     * containing all columns before [column], excluding [column] itself.
+     *
+     * [column] can be specified both relative to the current [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup] or the outer scope and
+     * can be referenced using any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi].
+     *
+     * If [column] does not exist, the function will return a [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns.
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * NOTE: Using the `{}` overloads of these functions requires a [ColumnSelector][org.jetbrains.kotlinx.dataframe.ColumnSelector]
+     * in the Plain DSL and on [column groups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     * On [ColumnSets][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] it requires a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter] instead.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[allBefore][ColumnsSelectionDsl.allBefore]`("someColumn") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup]`(Type::myColGroup).`[allColsBefore][SingleColumn.allColsBefore]`(someColumn) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsOf][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[Int][Int]`>().`[allBefore][ColumnSet.allBefore]`(Type::someColumn) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { DataSchemaType::someColGroup.`[allColsBefore][kotlin.reflect.KProperty.allColsBefore]`("myColumn") }`
+     *
+     * #### Flavors of All (Cols):
+     *
+     * - [`all(Cols)`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allCols]`()`:
+     *     All columns
+     *
+     * - [`all(Cols)Before`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsBefore]`(column)`:
+     *     All columns before the specified column, excluding that column
+     *
+     * - [`all(Cols)After`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsAfter]`(column)`:
+     *     All columns after the specified column, excluding that column
+     *
+     * - [`all(Cols)From`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsFrom]`(column)`:
+     *     All columns from the specified column, including that column
+     *
+     * - [`all(Cols)UpTo`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsUpTo]`(column)`:
+     *     All columns up to the specified column, including that column
+     *
+     * @return A new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns before [column], excluding [column] itself.
+     * @see [allBefore]
+     * @see [allAfter]
+     * @see [allFrom]
+     * @see [allUpTo]
+     * @see [ColumnsSelectionDsl.allExcept]
+     * @see [all]
+     * @see [cols]
+     * @param [column] The specified column before which all columns should be taken. This column can be referenced
+     *   to both relatively to the current [ColumnsResolver][org.jetbrains.kotlinx.dataframe.columns.ColumnsResolver] and absolutely.
+     */
+    public fun KProperty<*>.allColsBefore(column: String): ColumnSet<*> = columnGroup(this).allColsBefore(column)
+
+    /** ## All (Cols) Before
+     *
+     * Creates a new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] that contains a subset of columns from [this],
+     * containing all columns before [column], excluding [column] itself.
+     *
+     * [column] can be specified both relative to the current [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup] or the outer scope and
+     * can be referenced using any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi].
+     *
+     * If [column] does not exist, the function will return a [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns.
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * NOTE: Using the `{}` overloads of these functions requires a [ColumnSelector][org.jetbrains.kotlinx.dataframe.ColumnSelector]
+     * in the Plain DSL and on [column groups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     * On [ColumnSets][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] it requires a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter] instead.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[allBefore][ColumnsSelectionDsl.allBefore]`("someColumn") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup]`(Type::myColGroup).`[allColsBefore][SingleColumn.allColsBefore]`(someColumn) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsOf][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[Int][Int]`>().`[allBefore][ColumnSet.allBefore]`(Type::someColumn) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { DataSchemaType::someColGroup.`[allColsBefore][kotlin.reflect.KProperty.allColsBefore]`(myColumn) }`
+     *
+     * #### Flavors of All (Cols):
+     *
+     * - [`all(Cols)`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allCols]`()`:
+     *     All columns
+     *
+     * - [`all(Cols)Before`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsBefore]`(column)`:
+     *     All columns before the specified column, excluding that column
+     *
+     * - [`all(Cols)After`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsAfter]`(column)`:
+     *     All columns after the specified column, excluding that column
+     *
+     * - [`all(Cols)From`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsFrom]`(column)`:
+     *     All columns from the specified column, including that column
+     *
+     * - [`all(Cols)UpTo`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsUpTo]`(column)`:
+     *     All columns up to the specified column, including that column
+     *
+     * @return A new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns before [column], excluding [column] itself.
+     * @see [allBefore]
+     * @see [allAfter]
+     * @see [allFrom]
+     * @see [allUpTo]
+     * @see [ColumnsSelectionDsl.allExcept]
+     * @see [all]
+     * @see [cols]
+     * @param [column] The specified column before which all columns should be taken. This column can be referenced
+     *   to both relatively to the current [ColumnsResolver][org.jetbrains.kotlinx.dataframe.columns.ColumnsResolver] and absolutely.
+     */
+    public fun KProperty<*>.allColsBefore(column: AnyColumnReference): ColumnSet<*> =
+        columnGroup(this).allColsBefore(column)
+
+    /** ## All (Cols) Before
+     *
+     * Creates a new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] that contains a subset of columns from [this],
+     * containing all columns before [column], excluding [column] itself.
+     *
+     * [column] can be specified both relative to the current [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup] or the outer scope and
+     * can be referenced using any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi].
+     *
+     * If [column] does not exist, the function will return a [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns.
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * NOTE: Using the `{}` overloads of these functions requires a [ColumnSelector][org.jetbrains.kotlinx.dataframe.ColumnSelector]
+     * in the Plain DSL and on [column groups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     * On [ColumnSets][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] it requires a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter] instead.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[allBefore][ColumnsSelectionDsl.allBefore]`("someColumn") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup]`(Type::myColGroup).`[allColsBefore][SingleColumn.allColsBefore]`(someColumn) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsOf][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[Int][Int]`>().`[allBefore][ColumnSet.allBefore]`(Type::someColumn) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { DataSchemaType::someColGroup.`[allColsBefore][kotlin.reflect.KProperty.allColsBefore]`(Type::myColumn) }`
+     *
+     * #### Flavors of All (Cols):
+     *
+     * - [`all(Cols)`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allCols]`()`:
+     *     All columns
+     *
+     * - [`all(Cols)Before`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsBefore]`(column)`:
+     *     All columns before the specified column, excluding that column
+     *
+     * - [`all(Cols)After`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsAfter]`(column)`:
+     *     All columns after the specified column, excluding that column
+     *
+     * - [`all(Cols)From`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsFrom]`(column)`:
+     *     All columns from the specified column, including that column
+     *
+     * - [`all(Cols)UpTo`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsUpTo]`(column)`:
+     *     All columns up to the specified column, including that column
+     *
+     * @return A new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns before [column], excluding [column] itself.
+     * @see [allBefore]
+     * @see [allAfter]
+     * @see [allFrom]
+     * @see [allUpTo]
+     * @see [ColumnsSelectionDsl.allExcept]
+     * @see [all]
+     * @see [cols]
+     * @param [column] The specified column before which all columns should be taken. This column can be referenced
+     *   to both relatively to the current [ColumnsResolver][org.jetbrains.kotlinx.dataframe.columns.ColumnsResolver] and absolutely.
+     */
+    public fun KProperty<*>.allColsBefore(column: KProperty<*>): ColumnSet<*> = columnGroup(this).allColsBefore(column)
+
+    /** ## All (Cols) Before
+     *
+     * Creates a new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] that contains a subset of columns from [this],
+     * containing all columns before [column], excluding [column] itself.
+     *
+     * [column] can be specified both relative to the current [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup] or the outer scope and
+     * can be referenced using any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi].
+     *
+     * If [column] does not exist, the function will return a [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns.
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * NOTE: Using the `{}` overloads of these functions requires a [ColumnSelector][org.jetbrains.kotlinx.dataframe.ColumnSelector]
+     * in the Plain DSL and on [column groups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     * On [ColumnSets][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] it requires a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter] instead.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[allBefore][ColumnsSelectionDsl.allBefore]`("someColumn") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup]`(Type::myColGroup).`[allColsBefore][SingleColumn.allColsBefore]`(someColumn) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsOf][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[Int][Int]`>().`[allBefore][ColumnSet.allBefore]`(Type::someColumn) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "pathTo"["someColGroup"].`[allColsBefore][org.jetbrains.kotlinx.dataframe.columns.ColumnPath.allColsBefore]` { myColumn } }`
+     *
+     * #### Flavors of All (Cols):
+     *
+     * - [`all(Cols)`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allCols]`()`:
+     *     All columns
+     *
+     * - [`all(Cols)Before`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsBefore]`(column)`:
+     *     All columns before the specified column, excluding that column
+     *
+     * - [`all(Cols)After`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsAfter]`(column)`:
+     *     All columns after the specified column, excluding that column
+     *
+     * - [`all(Cols)From`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsFrom]`(column)`:
+     *     All columns from the specified column, including that column
+     *
+     * - [`all(Cols)UpTo`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsUpTo]`(column)`:
+     *     All columns up to the specified column, including that column
+     *
+     * @return A new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns before [column], excluding [column] itself.
+     * @see [allBefore]
+     * @see [allAfter]
+     * @see [allFrom]
+     * @see [allUpTo]
+     * @see [ColumnsSelectionDsl.allExcept]
+     * @see [all]
+     * @see [cols]
+     * @param [column] The specified column before which all columns should be taken. This column can be referenced
+     *   to both relatively to the current [ColumnsResolver][org.jetbrains.kotlinx.dataframe.columns.ColumnsResolver] and absolutely.
+     */
+    public fun ColumnPath.allColsBefore(column: ColumnSelector<*, *>): ColumnSet<*> =
+        columnGroup(this).allColsBefore(column)
+
+    /** ## All (Cols) Before
+     *
+     * Creates a new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] that contains a subset of columns from [this],
+     * containing all columns before [column], excluding [column] itself.
+     *
+     * [column] can be specified both relative to the current [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup] or the outer scope and
+     * can be referenced using any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi].
+     *
+     * If [column] does not exist, the function will return a [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns.
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * NOTE: Using the `{}` overloads of these functions requires a [ColumnSelector][org.jetbrains.kotlinx.dataframe.ColumnSelector]
+     * in the Plain DSL and on [column groups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     * On [ColumnSets][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] it requires a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter] instead.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[allBefore][ColumnsSelectionDsl.allBefore]`("someColumn") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup]`(Type::myColGroup).`[allColsBefore][SingleColumn.allColsBefore]`(someColumn) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsOf][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[Int][Int]`>().`[allBefore][ColumnSet.allBefore]`(Type::someColumn) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "pathTo"["someColGroup"].`[allColsBefore][org.jetbrains.kotlinx.dataframe.columns.ColumnPath.allColsBefore]`("pathTo"["myColumn"]) }`
+     *
+     * #### Flavors of All (Cols):
+     *
+     * - [`all(Cols)`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allCols]`()`:
+     *     All columns
+     *
+     * - [`all(Cols)Before`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsBefore]`(column)`:
+     *     All columns before the specified column, excluding that column
+     *
+     * - [`all(Cols)After`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsAfter]`(column)`:
+     *     All columns after the specified column, excluding that column
+     *
+     * - [`all(Cols)From`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsFrom]`(column)`:
+     *     All columns from the specified column, including that column
+     *
+     * - [`all(Cols)UpTo`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsUpTo]`(column)`:
+     *     All columns up to the specified column, including that column
+     *
+     * @return A new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns before [column], excluding [column] itself.
+     * @see [allBefore]
+     * @see [allAfter]
+     * @see [allFrom]
+     * @see [allUpTo]
+     * @see [ColumnsSelectionDsl.allExcept]
+     * @see [all]
+     * @see [cols]
+     * @param [column] The specified column before which all columns should be taken. This column can be referenced
+     *   to both relatively to the current [ColumnsResolver][org.jetbrains.kotlinx.dataframe.columns.ColumnsResolver] and absolutely.
+     */
+    public fun ColumnPath.allColsBefore(column: ColumnPath): ColumnSet<*> = columnGroup(this).allColsBefore(column)
+
+    /** ## All (Cols) Before
+     *
+     * Creates a new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] that contains a subset of columns from [this],
+     * containing all columns before [column], excluding [column] itself.
+     *
+     * [column] can be specified both relative to the current [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup] or the outer scope and
+     * can be referenced using any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi].
+     *
+     * If [column] does not exist, the function will return a [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns.
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * NOTE: Using the `{}` overloads of these functions requires a [ColumnSelector][org.jetbrains.kotlinx.dataframe.ColumnSelector]
+     * in the Plain DSL and on [column groups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     * On [ColumnSets][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] it requires a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter] instead.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[allBefore][ColumnsSelectionDsl.allBefore]`("someColumn") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup]`(Type::myColGroup).`[allColsBefore][SingleColumn.allColsBefore]`(someColumn) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsOf][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[Int][Int]`>().`[allBefore][ColumnSet.allBefore]`(Type::someColumn) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "pathTo"["someColGroup"].`[allColsBefore][org.jetbrains.kotlinx.dataframe.columns.ColumnPath.allColsBefore]`("myColumn") }`
+     *
+     * #### Flavors of All (Cols):
+     *
+     * - [`all(Cols)`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allCols]`()`:
+     *     All columns
+     *
+     * - [`all(Cols)Before`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsBefore]`(column)`:
+     *     All columns before the specified column, excluding that column
+     *
+     * - [`all(Cols)After`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsAfter]`(column)`:
+     *     All columns after the specified column, excluding that column
+     *
+     * - [`all(Cols)From`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsFrom]`(column)`:
+     *     All columns from the specified column, including that column
+     *
+     * - [`all(Cols)UpTo`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsUpTo]`(column)`:
+     *     All columns up to the specified column, including that column
+     *
+     * @return A new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns before [column], excluding [column] itself.
+     * @see [allBefore]
+     * @see [allAfter]
+     * @see [allFrom]
+     * @see [allUpTo]
+     * @see [ColumnsSelectionDsl.allExcept]
+     * @see [all]
+     * @see [cols]
+     * @param [column] The specified column before which all columns should be taken. This column can be referenced
+     *   to both relatively to the current [ColumnsResolver][org.jetbrains.kotlinx.dataframe.columns.ColumnsResolver] and absolutely.
+     */
+    public fun ColumnPath.allColsBefore(column: String): ColumnSet<*> = columnGroup(this).allColsBefore(column)
+
+    /** ## All (Cols) Before
+     *
+     * Creates a new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] that contains a subset of columns from [this],
+     * containing all columns before [column], excluding [column] itself.
+     *
+     * [column] can be specified both relative to the current [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup] or the outer scope and
+     * can be referenced using any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi].
+     *
+     * If [column] does not exist, the function will return a [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns.
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * NOTE: Using the `{}` overloads of these functions requires a [ColumnSelector][org.jetbrains.kotlinx.dataframe.ColumnSelector]
+     * in the Plain DSL and on [column groups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     * On [ColumnSets][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] it requires a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter] instead.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[allBefore][ColumnsSelectionDsl.allBefore]`("someColumn") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup]`(Type::myColGroup).`[allColsBefore][SingleColumn.allColsBefore]`(someColumn) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsOf][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[Int][Int]`>().`[allBefore][ColumnSet.allBefore]`(Type::someColumn) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "pathTo"["someColGroup"].`[allColsBefore][org.jetbrains.kotlinx.dataframe.columns.ColumnPath.allColsBefore]`(myColumn) }`
+     *
+     * #### Flavors of All (Cols):
+     *
+     * - [`all(Cols)`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allCols]`()`:
+     *     All columns
+     *
+     * - [`all(Cols)Before`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsBefore]`(column)`:
+     *     All columns before the specified column, excluding that column
+     *
+     * - [`all(Cols)After`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsAfter]`(column)`:
+     *     All columns after the specified column, excluding that column
+     *
+     * - [`all(Cols)From`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsFrom]`(column)`:
+     *     All columns from the specified column, including that column
+     *
+     * - [`all(Cols)UpTo`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsUpTo]`(column)`:
+     *     All columns up to the specified column, including that column
+     *
+     * @return A new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns before [column], excluding [column] itself.
+     * @see [allBefore]
+     * @see [allAfter]
+     * @see [allFrom]
+     * @see [allUpTo]
+     * @see [ColumnsSelectionDsl.allExcept]
+     * @see [all]
+     * @see [cols]
+     * @param [column] The specified column before which all columns should be taken. This column can be referenced
+     *   to both relatively to the current [ColumnsResolver][org.jetbrains.kotlinx.dataframe.columns.ColumnsResolver] and absolutely.
+     */
+    public fun ColumnPath.allColsBefore(column: AnyColumnReference): ColumnSet<*> =
+        columnGroup(this).allColsBefore(column)
+
+    /** ## All (Cols) Before
+     *
+     * Creates a new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] that contains a subset of columns from [this],
+     * containing all columns before [column], excluding [column] itself.
+     *
+     * [column] can be specified both relative to the current [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup] or the outer scope and
+     * can be referenced using any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi].
+     *
+     * If [column] does not exist, the function will return a [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns.
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * NOTE: Using the `{}` overloads of these functions requires a [ColumnSelector][org.jetbrains.kotlinx.dataframe.ColumnSelector]
+     * in the Plain DSL and on [column groups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     * On [ColumnSets][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] it requires a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter] instead.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[allBefore][ColumnsSelectionDsl.allBefore]`("someColumn") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup]`(Type::myColGroup).`[allColsBefore][SingleColumn.allColsBefore]`(someColumn) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsOf][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[Int][Int]`>().`[allBefore][ColumnSet.allBefore]`(Type::someColumn) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "pathTo"["someColGroup"].`[allColsBefore][org.jetbrains.kotlinx.dataframe.columns.ColumnPath.allColsBefore]`(Type::myColumn) }`
+     *
+     * #### Flavors of All (Cols):
+     *
+     * - [`all(Cols)`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allCols]`()`:
+     *     All columns
+     *
+     * - [`all(Cols)Before`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsBefore]`(column)`:
+     *     All columns before the specified column, excluding that column
+     *
+     * - [`all(Cols)After`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsAfter]`(column)`:
+     *     All columns after the specified column, excluding that column
+     *
+     * - [`all(Cols)From`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsFrom]`(column)`:
+     *     All columns from the specified column, including that column
+     *
+     * - [`all(Cols)UpTo`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsUpTo]`(column)`:
+     *     All columns up to the specified column, including that column
+     *
+     * @return A new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns before [column], excluding [column] itself.
+     * @see [allBefore]
+     * @see [allAfter]
+     * @see [allFrom]
+     * @see [allUpTo]
+     * @see [ColumnsSelectionDsl.allExcept]
+     * @see [all]
+     * @see [cols]
+     * @param [column] The specified column before which all columns should be taken. This column can be referenced
+     *   to both relatively to the current [ColumnsResolver][org.jetbrains.kotlinx.dataframe.columns.ColumnsResolver] and absolutely.
+     */
+    public fun ColumnPath.allColsBefore(column: KProperty<*>): ColumnSet<*> = columnGroup(this).allColsBefore(column)
+
+    // endregion
+
+    // region allUpTo
+
+    /**
+     * ## All (Cols) Up To
+     *
+     * Creates a new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] that contains a subset of columns from [this],
+     * containing all columns up to [column], including [column] itself.
+     *
+     * [column] can be specified both relative to the current [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup] or the outer scope and
+     * can be referenced using any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi].
+     *
+     * If [column] does not exist, the function will return a [ColumnSet][ColumnSet] containing all columns.
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * NOTE: Using the `{}` overloads of these functions requires a [ColumnSelector][org.jetbrains.kotlinx.dataframe.ColumnSelector]
+     * in the Plain DSL and on [column groups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     * On [ColumnSets][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] it requires a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter] instead.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[allUpTo][ColumnsSelectionDsl.allUpTo]`("someColumn") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup]`(Type::myColGroup).`[allColsUpTo][SingleColumn.allColsUpTo]`(someColumn) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsOf][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[Int][Int]`>().`[allUpTo][ColumnSet.allUpTo]`(Type::someColumn) }`
+     *
+     * #### Examples for this overload:
+     *
+     *
+     *
+     * #### Flavors of All (Cols):
+     *
+     * - [`all(Cols)`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allCols]`()`:
+     *     All columns
+     *
+     * - [`all(Cols)Before`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsBefore]`(column)`:
+     *     All columns before the specified column, excluding that column
+     *
+     * - [`all(Cols)After`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsAfter]`(column)`:
+     *     All columns after the specified column, excluding that column
+     *
+     * - [`all(Cols)From`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsFrom]`(column)`:
+     *     All columns from the specified column, including that column
+     *
+     * - [`all(Cols)UpTo`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsUpTo]`(column)`:
+     *     All columns up to the specified column, including that column
+     *
+     * @return A new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns up to [column], including [column] itself.
+     * @see [allBefore]
+     * @see [allAfter]
+     * @see [allFrom]
+     * @see [allUpTo]
+     * @see [ColumnsSelectionDsl.allExcept]
+     * @see [all]
+     * @see [cols]
+     * @param [column] The specified column up to which all columns should be taken. This column can be referenced
+     *   to both relatively to the current [ColumnsResolver] and absolutely.
+     */
+    private interface AllUpToDocs
+
+    /** ## All (Cols) Up To
+     *
+     * Creates a new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] that contains a subset of columns from [this],
+     * containing all columns up to [column], including [column] itself.
+     *
+     * [column] can be specified both relative to the current [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup] or the outer scope and
+     * can be referenced using any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi].
+     *
+     * If [column] does not exist, the function will return a [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns.
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * NOTE: Using the `{}` overloads of these functions requires a [ColumnSelector][org.jetbrains.kotlinx.dataframe.ColumnSelector]
+     * in the Plain DSL and on [column groups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     * On [ColumnSets][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] it requires a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter] instead.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[allUpTo][ColumnsSelectionDsl.allUpTo]`("someColumn") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup]`(Type::myColGroup).`[allColsUpTo][SingleColumn.allColsUpTo]`(someColumn) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsOf][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[Int][Int]`>().`[allUpTo][ColumnSet.allUpTo]`(Type::someColumn) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]` { .. }.`[allUpTo][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.allUpTo]` { myColumn `[in][String.contains]` it.`[name][ColumnWithPath.name]` } }`
+     *
+     * #### Flavors of All (Cols):
+     *
+     * - [`all(Cols)`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allCols]`()`:
+     *     All columns
+     *
+     * - [`all(Cols)Before`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsBefore]`(column)`:
+     *     All columns before the specified column, excluding that column
+     *
+     * - [`all(Cols)After`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsAfter]`(column)`:
+     *     All columns after the specified column, excluding that column
+     *
+     * - [`all(Cols)From`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsFrom]`(column)`:
+     *     All columns from the specified column, including that column
+     *
+     * - [`all(Cols)UpTo`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsUpTo]`(column)`:
+     *     All columns up to the specified column, including that column
+     *
+     * @return A new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns up to [column], including [column] itself.
+     * @see [allBefore]
+     * @see [allAfter]
+     * @see [allFrom]
+     * @see [allUpTo]
+     * @see [ColumnsSelectionDsl.allExcept]
+     * @see [all]
+     * @see [cols]
+     * @param [column] The specified column up to which all columns should be taken. This column can be referenced
+     *   to both relatively to the current [ColumnsResolver][org.jetbrains.kotlinx.dataframe.columns.ColumnsResolver] and absolutely.
+     */
+    @Suppress("UNCHECKED_CAST")
+    public fun <C> ColumnSet<C>.allUpTo(column: ColumnFilter<C>): ColumnSet<C> =
+        allUpToInternal(column as ColumnFilter<*>) as ColumnSet<C>
+
+    /** ## All (Cols) Up To
+     *
+     * Creates a new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] that contains a subset of columns from [this],
+     * containing all columns up to [column], including [column] itself.
+     *
+     * [column] can be specified both relative to the current [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup] or the outer scope and
+     * can be referenced using any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi].
+     *
+     * If [column] does not exist, the function will return a [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns.
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * NOTE: Using the `{}` overloads of these functions requires a [ColumnSelector][org.jetbrains.kotlinx.dataframe.ColumnSelector]
+     * in the Plain DSL and on [column groups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     * On [ColumnSets][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] it requires a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter] instead.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[allUpTo][ColumnsSelectionDsl.allUpTo]`("someColumn") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup]`(Type::myColGroup).`[allColsUpTo][SingleColumn.allColsUpTo]`(someColumn) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsOf][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[Int][Int]`>().`[allUpTo][ColumnSet.allUpTo]`(Type::someColumn) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]` { .. }.`[allUpTo][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.allUpTo]`("pathTo"["myColumn"]) }`
+     *
+     * #### Flavors of All (Cols):
+     *
+     * - [`all(Cols)`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allCols]`()`:
+     *     All columns
+     *
+     * - [`all(Cols)Before`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsBefore]`(column)`:
+     *     All columns before the specified column, excluding that column
+     *
+     * - [`all(Cols)After`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsAfter]`(column)`:
+     *     All columns after the specified column, excluding that column
+     *
+     * - [`all(Cols)From`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsFrom]`(column)`:
+     *     All columns from the specified column, including that column
+     *
+     * - [`all(Cols)UpTo`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsUpTo]`(column)`:
+     *     All columns up to the specified column, including that column
+     *
+     * @return A new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns up to [column], including [column] itself.
+     * @see [allBefore]
+     * @see [allAfter]
+     * @see [allFrom]
+     * @see [allUpTo]
+     * @see [ColumnsSelectionDsl.allExcept]
+     * @see [all]
+     * @see [cols]
+     * @param [column] The specified column up to which all columns should be taken. This column can be referenced
+     *   to both relatively to the current [ColumnsResolver][org.jetbrains.kotlinx.dataframe.columns.ColumnsResolver] and absolutely.
+     */
+    @Suppress("UNCHECKED_CAST")
+    public fun <C> ColumnSet<C>.allUpTo(column: ColumnPath): ColumnSet<C> =
+        allUpToInternal { it.path == column } as ColumnSet<C>
+
+    /** ## All (Cols) Up To
+     *
+     * Creates a new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] that contains a subset of columns from [this],
+     * containing all columns up to [column], including [column] itself.
+     *
+     * [column] can be specified both relative to the current [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup] or the outer scope and
+     * can be referenced using any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi].
+     *
+     * If [column] does not exist, the function will return a [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns.
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * NOTE: Using the `{}` overloads of these functions requires a [ColumnSelector][org.jetbrains.kotlinx.dataframe.ColumnSelector]
+     * in the Plain DSL and on [column groups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     * On [ColumnSets][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] it requires a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter] instead.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[allUpTo][ColumnsSelectionDsl.allUpTo]`("someColumn") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup]`(Type::myColGroup).`[allColsUpTo][SingleColumn.allColsUpTo]`(someColumn) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsOf][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[Int][Int]`>().`[allUpTo][ColumnSet.allUpTo]`(Type::someColumn) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]` { .. }.`[allUpTo][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.allUpTo]`("myColumn") }`
+     *
+     * #### Flavors of All (Cols):
+     *
+     * - [`all(Cols)`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allCols]`()`:
+     *     All columns
+     *
+     * - [`all(Cols)Before`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsBefore]`(column)`:
+     *     All columns before the specified column, excluding that column
+     *
+     * - [`all(Cols)After`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsAfter]`(column)`:
+     *     All columns after the specified column, excluding that column
+     *
+     * - [`all(Cols)From`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsFrom]`(column)`:
+     *     All columns from the specified column, including that column
+     *
+     * - [`all(Cols)UpTo`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsUpTo]`(column)`:
+     *     All columns up to the specified column, including that column
+     *
+     * @return A new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns up to [column], including [column] itself.
+     * @see [allBefore]
+     * @see [allAfter]
+     * @see [allFrom]
+     * @see [allUpTo]
+     * @see [ColumnsSelectionDsl.allExcept]
+     * @see [all]
+     * @see [cols]
+     * @param [column] The specified column up to which all columns should be taken. This column can be referenced
+     *   to both relatively to the current [ColumnsResolver][org.jetbrains.kotlinx.dataframe.columns.ColumnsResolver] and absolutely.
+     */
+    public fun <C> ColumnSet<C>.allUpTo(column: String): ColumnSet<C> = allUpTo(pathOf(column))
+
+    /** ## All (Cols) Up To
+     *
+     * Creates a new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] that contains a subset of columns from [this],
+     * containing all columns up to [column], including [column] itself.
+     *
+     * [column] can be specified both relative to the current [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup] or the outer scope and
+     * can be referenced using any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi].
+     *
+     * If [column] does not exist, the function will return a [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns.
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * NOTE: Using the `{}` overloads of these functions requires a [ColumnSelector][org.jetbrains.kotlinx.dataframe.ColumnSelector]
+     * in the Plain DSL and on [column groups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     * On [ColumnSets][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] it requires a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter] instead.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[allUpTo][ColumnsSelectionDsl.allUpTo]`("someColumn") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup]`(Type::myColGroup).`[allColsUpTo][SingleColumn.allColsUpTo]`(someColumn) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsOf][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[Int][Int]`>().`[allUpTo][ColumnSet.allUpTo]`(Type::someColumn) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]` { .. }.`[allUpTo][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.allUpTo]`(myColumn) }`
+     *
+     * #### Flavors of All (Cols):
+     *
+     * - [`all(Cols)`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allCols]`()`:
+     *     All columns
+     *
+     * - [`all(Cols)Before`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsBefore]`(column)`:
+     *     All columns before the specified column, excluding that column
+     *
+     * - [`all(Cols)After`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsAfter]`(column)`:
+     *     All columns after the specified column, excluding that column
+     *
+     * - [`all(Cols)From`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsFrom]`(column)`:
+     *     All columns from the specified column, including that column
+     *
+     * - [`all(Cols)UpTo`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsUpTo]`(column)`:
+     *     All columns up to the specified column, including that column
+     *
+     * @return A new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns up to [column], including [column] itself.
+     * @see [allBefore]
+     * @see [allAfter]
+     * @see [allFrom]
+     * @see [allUpTo]
+     * @see [ColumnsSelectionDsl.allExcept]
+     * @see [all]
+     * @see [cols]
+     * @param [column] The specified column up to which all columns should be taken. This column can be referenced
+     *   to both relatively to the current [ColumnsResolver][org.jetbrains.kotlinx.dataframe.columns.ColumnsResolver] and absolutely.
+     */
+    public fun <C> ColumnSet<C>.allUpTo(column: AnyColumnReference): ColumnSet<C> = allUpTo(column.path())
+
+    /** ## All (Cols) Up To
+     *
+     * Creates a new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] that contains a subset of columns from [this],
+     * containing all columns up to [column], including [column] itself.
+     *
+     * [column] can be specified both relative to the current [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup] or the outer scope and
+     * can be referenced using any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi].
+     *
+     * If [column] does not exist, the function will return a [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns.
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * NOTE: Using the `{}` overloads of these functions requires a [ColumnSelector][org.jetbrains.kotlinx.dataframe.ColumnSelector]
+     * in the Plain DSL and on [column groups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     * On [ColumnSets][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] it requires a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter] instead.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[allUpTo][ColumnsSelectionDsl.allUpTo]`("someColumn") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup]`(Type::myColGroup).`[allColsUpTo][SingleColumn.allColsUpTo]`(someColumn) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsOf][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[Int][Int]`>().`[allUpTo][ColumnSet.allUpTo]`(Type::someColumn) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]` { .. }.`[allUpTo][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.allUpTo]`(Type::myColumn) }`
+     *
+     * #### Flavors of All (Cols):
+     *
+     * - [`all(Cols)`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allCols]`()`:
+     *     All columns
+     *
+     * - [`all(Cols)Before`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsBefore]`(column)`:
+     *     All columns before the specified column, excluding that column
+     *
+     * - [`all(Cols)After`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsAfter]`(column)`:
+     *     All columns after the specified column, excluding that column
+     *
+     * - [`all(Cols)From`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsFrom]`(column)`:
+     *     All columns from the specified column, including that column
+     *
+     * - [`all(Cols)UpTo`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsUpTo]`(column)`:
+     *     All columns up to the specified column, including that column
+     *
+     * @return A new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns up to [column], including [column] itself.
+     * @see [allBefore]
+     * @see [allAfter]
+     * @see [allFrom]
+     * @see [allUpTo]
+     * @see [ColumnsSelectionDsl.allExcept]
+     * @see [all]
+     * @see [cols]
+     * @param [column] The specified column up to which all columns should be taken. This column can be referenced
+     *   to both relatively to the current [ColumnsResolver][org.jetbrains.kotlinx.dataframe.columns.ColumnsResolver] and absolutely.
+     */
+    public fun <C> ColumnSet<C>.allUpTo(column: KProperty<*>): ColumnSet<C> = allUpTo(column.toColumnAccessor().path())
+
+    /** ## All (Cols) Up To
+     *
+     * Creates a new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] that contains a subset of columns from [this],
+     * containing all columns up to [column], including [column] itself.
+     *
+     * [column] can be specified both relative to the current [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup] or the outer scope and
+     * can be referenced using any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi].
+     *
+     * If [column] does not exist, the function will return a [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns.
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * NOTE: Using the `{}` overloads of these functions requires a [ColumnSelector][org.jetbrains.kotlinx.dataframe.ColumnSelector]
+     * in the Plain DSL and on [column groups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     * On [ColumnSets][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] it requires a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter] instead.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[allUpTo][ColumnsSelectionDsl.allUpTo]`("someColumn") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup]`(Type::myColGroup).`[allColsUpTo][SingleColumn.allColsUpTo]`(someColumn) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsOf][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[Int][Int]`>().`[allUpTo][ColumnSet.allUpTo]`(Type::someColumn) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[allUpTo][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsUpTo]` { myColumn } }`
+     *
+     * #### Flavors of All (Cols):
+     *
+     * - [`all(Cols)`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allCols]`()`:
+     *     All columns
+     *
+     * - [`all(Cols)Before`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsBefore]`(column)`:
+     *     All columns before the specified column, excluding that column
+     *
+     * - [`all(Cols)After`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsAfter]`(column)`:
+     *     All columns after the specified column, excluding that column
+     *
+     * - [`all(Cols)From`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsFrom]`(column)`:
+     *     All columns from the specified column, including that column
+     *
+     * - [`all(Cols)UpTo`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsUpTo]`(column)`:
+     *     All columns up to the specified column, including that column
+     *
+     * @return A new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns up to [column], including [column] itself.
+     * @see [allBefore]
+     * @see [allAfter]
+     * @see [allFrom]
+     * @see [allUpTo]
+     * @see [ColumnsSelectionDsl.allExcept]
+     * @see [all]
+     * @see [cols]
+     * @param [column] The specified column up to which all columns should be taken. This column can be referenced
+     *   to both relatively to the current [ColumnsResolver][org.jetbrains.kotlinx.dataframe.columns.ColumnsResolver] and absolutely.
+     */
+    public fun <T> ColumnsSelectionDsl<T>.allUpTo(column: ColumnSelector<T, *>): ColumnSet<*> =
+        asSingleColumn().allColsUpTo(column)
+
+    /** ## All (Cols) Up To
+     *
+     * Creates a new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] that contains a subset of columns from [this],
+     * containing all columns up to [column], including [column] itself.
+     *
+     * [column] can be specified both relative to the current [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup] or the outer scope and
+     * can be referenced using any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi].
+     *
+     * If [column] does not exist, the function will return a [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns.
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * NOTE: Using the `{}` overloads of these functions requires a [ColumnSelector][org.jetbrains.kotlinx.dataframe.ColumnSelector]
+     * in the Plain DSL and on [column groups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     * On [ColumnSets][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] it requires a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter] instead.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[allUpTo][ColumnsSelectionDsl.allUpTo]`("someColumn") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup]`(Type::myColGroup).`[allColsUpTo][SingleColumn.allColsUpTo]`(someColumn) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsOf][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[Int][Int]`>().`[allUpTo][ColumnSet.allUpTo]`(Type::someColumn) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[allUpTo][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsUpTo]`("pathTo"["myColumn"]) }`
+     *
+     * #### Flavors of All (Cols):
+     *
+     * - [`all(Cols)`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allCols]`()`:
+     *     All columns
+     *
+     * - [`all(Cols)Before`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsBefore]`(column)`:
+     *     All columns before the specified column, excluding that column
+     *
+     * - [`all(Cols)After`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsAfter]`(column)`:
+     *     All columns after the specified column, excluding that column
+     *
+     * - [`all(Cols)From`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsFrom]`(column)`:
+     *     All columns from the specified column, including that column
+     *
+     * - [`all(Cols)UpTo`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsUpTo]`(column)`:
+     *     All columns up to the specified column, including that column
+     *
+     * @return A new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns up to [column], including [column] itself.
+     * @see [allBefore]
+     * @see [allAfter]
+     * @see [allFrom]
+     * @see [allUpTo]
+     * @see [ColumnsSelectionDsl.allExcept]
+     * @see [all]
+     * @see [cols]
+     * @param [column] The specified column up to which all columns should be taken. This column can be referenced
+     *   to both relatively to the current [ColumnsResolver][org.jetbrains.kotlinx.dataframe.columns.ColumnsResolver] and absolutely.
+     */
+    public fun ColumnsSelectionDsl<*>.allUpTo(column: ColumnPath): ColumnSet<*> = asSingleColumn().allColsUpTo(column)
+
+    /** ## All (Cols) Up To
+     *
+     * Creates a new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] that contains a subset of columns from [this],
+     * containing all columns up to [column], including [column] itself.
+     *
+     * [column] can be specified both relative to the current [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup] or the outer scope and
+     * can be referenced using any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi].
+     *
+     * If [column] does not exist, the function will return a [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns.
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * NOTE: Using the `{}` overloads of these functions requires a [ColumnSelector][org.jetbrains.kotlinx.dataframe.ColumnSelector]
+     * in the Plain DSL and on [column groups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     * On [ColumnSets][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] it requires a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter] instead.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[allUpTo][ColumnsSelectionDsl.allUpTo]`("someColumn") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup]`(Type::myColGroup).`[allColsUpTo][SingleColumn.allColsUpTo]`(someColumn) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsOf][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[Int][Int]`>().`[allUpTo][ColumnSet.allUpTo]`(Type::someColumn) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[allUpTo][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsUpTo]`("myColumn") }`
+     *
+     * #### Flavors of All (Cols):
+     *
+     * - [`all(Cols)`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allCols]`()`:
+     *     All columns
+     *
+     * - [`all(Cols)Before`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsBefore]`(column)`:
+     *     All columns before the specified column, excluding that column
+     *
+     * - [`all(Cols)After`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsAfter]`(column)`:
+     *     All columns after the specified column, excluding that column
+     *
+     * - [`all(Cols)From`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsFrom]`(column)`:
+     *     All columns from the specified column, including that column
+     *
+     * - [`all(Cols)UpTo`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsUpTo]`(column)`:
+     *     All columns up to the specified column, including that column
+     *
+     * @return A new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns up to [column], including [column] itself.
+     * @see [allBefore]
+     * @see [allAfter]
+     * @see [allFrom]
+     * @see [allUpTo]
+     * @see [ColumnsSelectionDsl.allExcept]
+     * @see [all]
+     * @see [cols]
+     * @param [column] The specified column up to which all columns should be taken. This column can be referenced
+     *   to both relatively to the current [ColumnsResolver][org.jetbrains.kotlinx.dataframe.columns.ColumnsResolver] and absolutely.
+     */
+    public fun ColumnsSelectionDsl<*>.allUpTo(column: String): ColumnSet<*> = asSingleColumn().allColsUpTo(column)
+
+    /** ## All (Cols) Up To
+     *
+     * Creates a new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] that contains a subset of columns from [this],
+     * containing all columns up to [column], including [column] itself.
+     *
+     * [column] can be specified both relative to the current [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup] or the outer scope and
+     * can be referenced using any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi].
+     *
+     * If [column] does not exist, the function will return a [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns.
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * NOTE: Using the `{}` overloads of these functions requires a [ColumnSelector][org.jetbrains.kotlinx.dataframe.ColumnSelector]
+     * in the Plain DSL and on [column groups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     * On [ColumnSets][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] it requires a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter] instead.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[allUpTo][ColumnsSelectionDsl.allUpTo]`("someColumn") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup]`(Type::myColGroup).`[allColsUpTo][SingleColumn.allColsUpTo]`(someColumn) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsOf][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[Int][Int]`>().`[allUpTo][ColumnSet.allUpTo]`(Type::someColumn) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[allUpTo][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsUpTo]`(myColumn) }`
+     *
+     * #### Flavors of All (Cols):
+     *
+     * - [`all(Cols)`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allCols]`()`:
+     *     All columns
+     *
+     * - [`all(Cols)Before`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsBefore]`(column)`:
+     *     All columns before the specified column, excluding that column
+     *
+     * - [`all(Cols)After`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsAfter]`(column)`:
+     *     All columns after the specified column, excluding that column
+     *
+     * - [`all(Cols)From`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsFrom]`(column)`:
+     *     All columns from the specified column, including that column
+     *
+     * - [`all(Cols)UpTo`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsUpTo]`(column)`:
+     *     All columns up to the specified column, including that column
+     *
+     * @return A new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns up to [column], including [column] itself.
+     * @see [allBefore]
+     * @see [allAfter]
+     * @see [allFrom]
+     * @see [allUpTo]
+     * @see [ColumnsSelectionDsl.allExcept]
+     * @see [all]
+     * @see [cols]
+     * @param [column] The specified column up to which all columns should be taken. This column can be referenced
+     *   to both relatively to the current [ColumnsResolver][org.jetbrains.kotlinx.dataframe.columns.ColumnsResolver] and absolutely.
+     */
+    public fun ColumnsSelectionDsl<*>.allUpTo(column: AnyColumnReference): ColumnSet<*> =
+        asSingleColumn().allColsUpTo(column)
+
+    /** ## All (Cols) Up To
+     *
+     * Creates a new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] that contains a subset of columns from [this],
+     * containing all columns up to [column], including [column] itself.
+     *
+     * [column] can be specified both relative to the current [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup] or the outer scope and
+     * can be referenced using any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi].
+     *
+     * If [column] does not exist, the function will return a [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns.
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * NOTE: Using the `{}` overloads of these functions requires a [ColumnSelector][org.jetbrains.kotlinx.dataframe.ColumnSelector]
+     * in the Plain DSL and on [column groups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     * On [ColumnSets][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] it requires a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter] instead.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[allUpTo][ColumnsSelectionDsl.allUpTo]`("someColumn") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup]`(Type::myColGroup).`[allColsUpTo][SingleColumn.allColsUpTo]`(someColumn) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsOf][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[Int][Int]`>().`[allUpTo][ColumnSet.allUpTo]`(Type::someColumn) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[allUpTo][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsUpTo]`(Type::myColumn) }`
+     *
+     * #### Flavors of All (Cols):
+     *
+     * - [`all(Cols)`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allCols]`()`:
+     *     All columns
+     *
+     * - [`all(Cols)Before`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsBefore]`(column)`:
+     *     All columns before the specified column, excluding that column
+     *
+     * - [`all(Cols)After`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsAfter]`(column)`:
+     *     All columns after the specified column, excluding that column
+     *
+     * - [`all(Cols)From`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsFrom]`(column)`:
+     *     All columns from the specified column, including that column
+     *
+     * - [`all(Cols)UpTo`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsUpTo]`(column)`:
+     *     All columns up to the specified column, including that column
+     *
+     * @return A new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns up to [column], including [column] itself.
+     * @see [allBefore]
+     * @see [allAfter]
+     * @see [allFrom]
+     * @see [allUpTo]
+     * @see [ColumnsSelectionDsl.allExcept]
+     * @see [all]
+     * @see [cols]
+     * @param [column] The specified column up to which all columns should be taken. This column can be referenced
+     *   to both relatively to the current [ColumnsResolver][org.jetbrains.kotlinx.dataframe.columns.ColumnsResolver] and absolutely.
+     */
+    public fun ColumnsSelectionDsl<*>.allUpTo(column: KProperty<*>): ColumnSet<*> = asSingleColumn().allColsUpTo(column)
+
+    /** ## All (Cols) Up To
+     *
+     * Creates a new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] that contains a subset of columns from [this],
+     * containing all columns up to [column], including [column] itself.
+     *
+     * [column] can be specified both relative to the current [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup] or the outer scope and
+     * can be referenced using any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi].
+     *
+     * If [column] does not exist, the function will return a [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns.
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * NOTE: Using the `{}` overloads of these functions requires a [ColumnSelector][org.jetbrains.kotlinx.dataframe.ColumnSelector]
+     * in the Plain DSL and on [column groups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     * On [ColumnSets][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] it requires a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter] instead.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[allUpTo][ColumnsSelectionDsl.allUpTo]`("someColumn") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup]`(Type::myColGroup).`[allColsUpTo][SingleColumn.allColsUpTo]`(someColumn) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsOf][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[Int][Int]`>().`[allUpTo][ColumnSet.allUpTo]`(Type::someColumn) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { someColumnGroup.`[allColsUpTo][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.allColsUpTo]` { myColumn } }`
+     *
+     * #### Flavors of All (Cols):
+     *
+     * - [`all(Cols)`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allCols]`()`:
+     *     All columns
+     *
+     * - [`all(Cols)Before`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsBefore]`(column)`:
+     *     All columns before the specified column, excluding that column
+     *
+     * - [`all(Cols)After`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsAfter]`(column)`:
+     *     All columns after the specified column, excluding that column
+     *
+     * - [`all(Cols)From`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsFrom]`(column)`:
+     *     All columns from the specified column, including that column
+     *
+     * - [`all(Cols)UpTo`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsUpTo]`(column)`:
+     *     All columns up to the specified column, including that column
+     *
+     * @return A new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns up to [column], including [column] itself.
+     * @see [allBefore]
+     * @see [allAfter]
+     * @see [allFrom]
+     * @see [allUpTo]
+     * @see [ColumnsSelectionDsl.allExcept]
+     * @see [all]
+     * @see [cols]
+     * @param [column] The specified column up to which all columns should be taken. This column can be referenced
+     *   to both relatively to the current [ColumnsResolver][org.jetbrains.kotlinx.dataframe.columns.ColumnsResolver] and absolutely.
+     */
+    public fun <T> SingleColumn<DataRow<T>>.allColsUpTo(column: ColumnSelector<T, *>): ColumnSet<*> {
+        var resolvedCol: DataColumn<*>? = null
+        return this
+            .ensureIsColumnGroup()
+            .onResolve { resolvedCol = it!!.asColumnGroup().getColumn(column) }
+            .allUpToInternal { it.data == resolvedCol!! }
+    }
+
+    /** ## All (Cols) Up To
+     *
+     * Creates a new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] that contains a subset of columns from [this],
+     * containing all columns up to [column], including [column] itself.
+     *
+     * [column] can be specified both relative to the current [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup] or the outer scope and
+     * can be referenced using any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi].
+     *
+     * If [column] does not exist, the function will return a [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns.
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * NOTE: Using the `{}` overloads of these functions requires a [ColumnSelector][org.jetbrains.kotlinx.dataframe.ColumnSelector]
+     * in the Plain DSL and on [column groups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     * On [ColumnSets][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] it requires a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter] instead.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[allUpTo][ColumnsSelectionDsl.allUpTo]`("someColumn") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup]`(Type::myColGroup).`[allColsUpTo][SingleColumn.allColsUpTo]`(someColumn) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsOf][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[Int][Int]`>().`[allUpTo][ColumnSet.allUpTo]`(Type::someColumn) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { someColumnGroup.`[allColsUpTo][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.allColsUpTo]`("pathTo"["myColumn"]) }`
+     *
+     * #### Flavors of All (Cols):
+     *
+     * - [`all(Cols)`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allCols]`()`:
+     *     All columns
+     *
+     * - [`all(Cols)Before`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsBefore]`(column)`:
+     *     All columns before the specified column, excluding that column
+     *
+     * - [`all(Cols)After`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsAfter]`(column)`:
+     *     All columns after the specified column, excluding that column
+     *
+     * - [`all(Cols)From`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsFrom]`(column)`:
+     *     All columns from the specified column, including that column
+     *
+     * - [`all(Cols)UpTo`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsUpTo]`(column)`:
+     *     All columns up to the specified column, including that column
+     *
+     * @return A new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns up to [column], including [column] itself.
+     * @see [allBefore]
+     * @see [allAfter]
+     * @see [allFrom]
+     * @see [allUpTo]
+     * @see [ColumnsSelectionDsl.allExcept]
+     * @see [all]
+     * @see [cols]
+     * @param [column] The specified column up to which all columns should be taken. This column can be referenced
+     *   to both relatively to the current [ColumnsResolver][org.jetbrains.kotlinx.dataframe.columns.ColumnsResolver] and absolutely.
+     */
+    public fun SingleColumn<DataRow<*>>.allColsUpTo(column: ColumnPath): ColumnSet<*> {
+        var path: ColumnPath? = null
+        return this
+            .ensureIsColumnGroup()
+            .onResolve { path = it!!.path }
+            .allUpToInternal {
+                // accept both relative and full column path
+                it.path == path!! + column || it.path == column
+            }
+    }
+
+    /** ## All (Cols) Up To
+     *
+     * Creates a new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] that contains a subset of columns from [this],
+     * containing all columns up to [column], including [column] itself.
+     *
+     * [column] can be specified both relative to the current [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup] or the outer scope and
+     * can be referenced using any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi].
+     *
+     * If [column] does not exist, the function will return a [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns.
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * NOTE: Using the `{}` overloads of these functions requires a [ColumnSelector][org.jetbrains.kotlinx.dataframe.ColumnSelector]
+     * in the Plain DSL and on [column groups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     * On [ColumnSets][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] it requires a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter] instead.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[allUpTo][ColumnsSelectionDsl.allUpTo]`("someColumn") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup]`(Type::myColGroup).`[allColsUpTo][SingleColumn.allColsUpTo]`(someColumn) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsOf][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[Int][Int]`>().`[allUpTo][ColumnSet.allUpTo]`(Type::someColumn) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { someColumnGroup.`[allColsUpTo][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.allColsUpTo]`("myColumn") }`
+     *
+     * #### Flavors of All (Cols):
+     *
+     * - [`all(Cols)`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allCols]`()`:
+     *     All columns
+     *
+     * - [`all(Cols)Before`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsBefore]`(column)`:
+     *     All columns before the specified column, excluding that column
+     *
+     * - [`all(Cols)After`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsAfter]`(column)`:
+     *     All columns after the specified column, excluding that column
+     *
+     * - [`all(Cols)From`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsFrom]`(column)`:
+     *     All columns from the specified column, including that column
+     *
+     * - [`all(Cols)UpTo`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsUpTo]`(column)`:
+     *     All columns up to the specified column, including that column
+     *
+     * @return A new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns up to [column], including [column] itself.
+     * @see [allBefore]
+     * @see [allAfter]
+     * @see [allFrom]
+     * @see [allUpTo]
+     * @see [ColumnsSelectionDsl.allExcept]
+     * @see [all]
+     * @see [cols]
+     * @param [column] The specified column up to which all columns should be taken. This column can be referenced
+     *   to both relatively to the current [ColumnsResolver][org.jetbrains.kotlinx.dataframe.columns.ColumnsResolver] and absolutely.
+     */
+    public fun SingleColumn<DataRow<*>>.allColsUpTo(column: String): ColumnSet<*> = allColsUpTo(pathOf(column))
+
+    /** ## All (Cols) Up To
+     *
+     * Creates a new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] that contains a subset of columns from [this],
+     * containing all columns up to [column], including [column] itself.
+     *
+     * [column] can be specified both relative to the current [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup] or the outer scope and
+     * can be referenced using any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi].
+     *
+     * If [column] does not exist, the function will return a [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns.
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * NOTE: Using the `{}` overloads of these functions requires a [ColumnSelector][org.jetbrains.kotlinx.dataframe.ColumnSelector]
+     * in the Plain DSL and on [column groups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     * On [ColumnSets][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] it requires a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter] instead.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[allUpTo][ColumnsSelectionDsl.allUpTo]`("someColumn") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup]`(Type::myColGroup).`[allColsUpTo][SingleColumn.allColsUpTo]`(someColumn) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsOf][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[Int][Int]`>().`[allUpTo][ColumnSet.allUpTo]`(Type::someColumn) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { someColumnGroup.`[allColsUpTo][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.allColsUpTo]`(myColumn) }`
+     *
+     * #### Flavors of All (Cols):
+     *
+     * - [`all(Cols)`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allCols]`()`:
+     *     All columns
+     *
+     * - [`all(Cols)Before`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsBefore]`(column)`:
+     *     All columns before the specified column, excluding that column
+     *
+     * - [`all(Cols)After`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsAfter]`(column)`:
+     *     All columns after the specified column, excluding that column
+     *
+     * - [`all(Cols)From`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsFrom]`(column)`:
+     *     All columns from the specified column, including that column
+     *
+     * - [`all(Cols)UpTo`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsUpTo]`(column)`:
+     *     All columns up to the specified column, including that column
+     *
+     * @return A new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns up to [column], including [column] itself.
+     * @see [allBefore]
+     * @see [allAfter]
+     * @see [allFrom]
+     * @see [allUpTo]
+     * @see [ColumnsSelectionDsl.allExcept]
+     * @see [all]
+     * @see [cols]
+     * @param [column] The specified column up to which all columns should be taken. This column can be referenced
+     *   to both relatively to the current [ColumnsResolver][org.jetbrains.kotlinx.dataframe.columns.ColumnsResolver] and absolutely.
+     */
+    public fun SingleColumn<DataRow<*>>.allColsUpTo(column: AnyColumnReference): ColumnSet<*> =
+        allColsUpTo(column.path())
+
+    /** ## All (Cols) Up To
+     *
+     * Creates a new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] that contains a subset of columns from [this],
+     * containing all columns up to [column], including [column] itself.
+     *
+     * [column] can be specified both relative to the current [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup] or the outer scope and
+     * can be referenced using any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi].
+     *
+     * If [column] does not exist, the function will return a [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns.
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * NOTE: Using the `{}` overloads of these functions requires a [ColumnSelector][org.jetbrains.kotlinx.dataframe.ColumnSelector]
+     * in the Plain DSL and on [column groups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     * On [ColumnSets][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] it requires a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter] instead.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[allUpTo][ColumnsSelectionDsl.allUpTo]`("someColumn") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup]`(Type::myColGroup).`[allColsUpTo][SingleColumn.allColsUpTo]`(someColumn) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsOf][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[Int][Int]`>().`[allUpTo][ColumnSet.allUpTo]`(Type::someColumn) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { someColumnGroup.`[allColsUpTo][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.allColsUpTo]`(Type::myColumn) }`
+     *
+     * #### Flavors of All (Cols):
+     *
+     * - [`all(Cols)`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allCols]`()`:
+     *     All columns
+     *
+     * - [`all(Cols)Before`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsBefore]`(column)`:
+     *     All columns before the specified column, excluding that column
+     *
+     * - [`all(Cols)After`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsAfter]`(column)`:
+     *     All columns after the specified column, excluding that column
+     *
+     * - [`all(Cols)From`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsFrom]`(column)`:
+     *     All columns from the specified column, including that column
+     *
+     * - [`all(Cols)UpTo`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsUpTo]`(column)`:
+     *     All columns up to the specified column, including that column
+     *
+     * @return A new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns up to [column], including [column] itself.
+     * @see [allBefore]
+     * @see [allAfter]
+     * @see [allFrom]
+     * @see [allUpTo]
+     * @see [ColumnsSelectionDsl.allExcept]
+     * @see [all]
+     * @see [cols]
+     * @param [column] The specified column up to which all columns should be taken. This column can be referenced
+     *   to both relatively to the current [ColumnsResolver][org.jetbrains.kotlinx.dataframe.columns.ColumnsResolver] and absolutely.
+     */
+    public fun SingleColumn<DataRow<*>>.allColsUpTo(column: KProperty<*>): ColumnSet<*> =
+        allColsUpTo(column.toColumnAccessor().path())
+
+    /** ## All (Cols) Up To
+     *
+     * Creates a new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] that contains a subset of columns from [this],
+     * containing all columns up to [column], including [column] itself.
+     *
+     * [column] can be specified both relative to the current [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup] or the outer scope and
+     * can be referenced using any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi].
+     *
+     * If [column] does not exist, the function will return a [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns.
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * NOTE: Using the `{}` overloads of these functions requires a [ColumnSelector][org.jetbrains.kotlinx.dataframe.ColumnSelector]
+     * in the Plain DSL and on [column groups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     * On [ColumnSets][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] it requires a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter] instead.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[allUpTo][ColumnsSelectionDsl.allUpTo]`("someColumn") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup]`(Type::myColGroup).`[allColsUpTo][SingleColumn.allColsUpTo]`(someColumn) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsOf][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[Int][Int]`>().`[allUpTo][ColumnSet.allUpTo]`(Type::someColumn) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "someColGroup".`[allColsUpTo][kotlin.String.allColsUpTo]` { myColumn } }`
+     *
+     * #### Flavors of All (Cols):
+     *
+     * - [`all(Cols)`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allCols]`()`:
+     *     All columns
+     *
+     * - [`all(Cols)Before`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsBefore]`(column)`:
+     *     All columns before the specified column, excluding that column
+     *
+     * - [`all(Cols)After`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsAfter]`(column)`:
+     *     All columns after the specified column, excluding that column
+     *
+     * - [`all(Cols)From`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsFrom]`(column)`:
+     *     All columns from the specified column, including that column
+     *
+     * - [`all(Cols)UpTo`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsUpTo]`(column)`:
+     *     All columns up to the specified column, including that column
+     *
+     * @return A new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns up to [column], including [column] itself.
+     * @see [allBefore]
+     * @see [allAfter]
+     * @see [allFrom]
+     * @see [allUpTo]
+     * @see [ColumnsSelectionDsl.allExcept]
+     * @see [all]
+     * @see [cols]
+     * @param [column] The specified column up to which all columns should be taken. This column can be referenced
+     *   to both relatively to the current [ColumnsResolver][org.jetbrains.kotlinx.dataframe.columns.ColumnsResolver] and absolutely.
+     */
+    public fun String.allColsUpTo(column: ColumnSelector<*, *>): ColumnSet<*> = columnGroup(this).allColsUpTo(column)
+
+    /** ## All (Cols) Up To
+     *
+     * Creates a new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] that contains a subset of columns from [this],
+     * containing all columns up to [column], including [column] itself.
+     *
+     * [column] can be specified both relative to the current [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup] or the outer scope and
+     * can be referenced using any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi].
+     *
+     * If [column] does not exist, the function will return a [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns.
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * NOTE: Using the `{}` overloads of these functions requires a [ColumnSelector][org.jetbrains.kotlinx.dataframe.ColumnSelector]
+     * in the Plain DSL and on [column groups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     * On [ColumnSets][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] it requires a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter] instead.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[allUpTo][ColumnsSelectionDsl.allUpTo]`("someColumn") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup]`(Type::myColGroup).`[allColsUpTo][SingleColumn.allColsUpTo]`(someColumn) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsOf][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[Int][Int]`>().`[allUpTo][ColumnSet.allUpTo]`(Type::someColumn) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "someColGroup".`[allColsUpTo][kotlin.String.allColsUpTo]`("pathTo"["myColumn"]) }`
+     *
+     * #### Flavors of All (Cols):
+     *
+     * - [`all(Cols)`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allCols]`()`:
+     *     All columns
+     *
+     * - [`all(Cols)Before`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsBefore]`(column)`:
+     *     All columns before the specified column, excluding that column
+     *
+     * - [`all(Cols)After`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsAfter]`(column)`:
+     *     All columns after the specified column, excluding that column
+     *
+     * - [`all(Cols)From`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsFrom]`(column)`:
+     *     All columns from the specified column, including that column
+     *
+     * - [`all(Cols)UpTo`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsUpTo]`(column)`:
+     *     All columns up to the specified column, including that column
+     *
+     * @return A new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns up to [column], including [column] itself.
+     * @see [allBefore]
+     * @see [allAfter]
+     * @see [allFrom]
+     * @see [allUpTo]
+     * @see [ColumnsSelectionDsl.allExcept]
+     * @see [all]
+     * @see [cols]
+     * @param [column] The specified column up to which all columns should be taken. This column can be referenced
+     *   to both relatively to the current [ColumnsResolver][org.jetbrains.kotlinx.dataframe.columns.ColumnsResolver] and absolutely.
+     */
+    public fun String.allColsUpTo(column: ColumnPath): ColumnSet<*> = columnGroup(this).allColsUpTo(column)
+
+    /** ## All (Cols) Up To
+     *
+     * Creates a new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] that contains a subset of columns from [this],
+     * containing all columns up to [column], including [column] itself.
+     *
+     * [column] can be specified both relative to the current [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup] or the outer scope and
+     * can be referenced using any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi].
+     *
+     * If [column] does not exist, the function will return a [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns.
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * NOTE: Using the `{}` overloads of these functions requires a [ColumnSelector][org.jetbrains.kotlinx.dataframe.ColumnSelector]
+     * in the Plain DSL and on [column groups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     * On [ColumnSets][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] it requires a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter] instead.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[allUpTo][ColumnsSelectionDsl.allUpTo]`("someColumn") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup]`(Type::myColGroup).`[allColsUpTo][SingleColumn.allColsUpTo]`(someColumn) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsOf][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[Int][Int]`>().`[allUpTo][ColumnSet.allUpTo]`(Type::someColumn) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "someColGroup".`[allColsUpTo][kotlin.String.allColsUpTo]`("myColumn") }`
+     *
+     * #### Flavors of All (Cols):
+     *
+     * - [`all(Cols)`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allCols]`()`:
+     *     All columns
+     *
+     * - [`all(Cols)Before`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsBefore]`(column)`:
+     *     All columns before the specified column, excluding that column
+     *
+     * - [`all(Cols)After`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsAfter]`(column)`:
+     *     All columns after the specified column, excluding that column
+     *
+     * - [`all(Cols)From`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsFrom]`(column)`:
+     *     All columns from the specified column, including that column
+     *
+     * - [`all(Cols)UpTo`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsUpTo]`(column)`:
+     *     All columns up to the specified column, including that column
+     *
+     * @return A new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns up to [column], including [column] itself.
+     * @see [allBefore]
+     * @see [allAfter]
+     * @see [allFrom]
+     * @see [allUpTo]
+     * @see [ColumnsSelectionDsl.allExcept]
+     * @see [all]
+     * @see [cols]
+     * @param [column] The specified column up to which all columns should be taken. This column can be referenced
+     *   to both relatively to the current [ColumnsResolver][org.jetbrains.kotlinx.dataframe.columns.ColumnsResolver] and absolutely.
+     */
+    public fun String.allColsUpTo(column: String): ColumnSet<*> = columnGroup(this).allColsUpTo(column)
+
+    /** ## All (Cols) Up To
+     *
+     * Creates a new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] that contains a subset of columns from [this],
+     * containing all columns up to [column], including [column] itself.
+     *
+     * [column] can be specified both relative to the current [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup] or the outer scope and
+     * can be referenced using any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi].
+     *
+     * If [column] does not exist, the function will return a [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns.
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * NOTE: Using the `{}` overloads of these functions requires a [ColumnSelector][org.jetbrains.kotlinx.dataframe.ColumnSelector]
+     * in the Plain DSL and on [column groups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     * On [ColumnSets][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] it requires a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter] instead.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[allUpTo][ColumnsSelectionDsl.allUpTo]`("someColumn") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup]`(Type::myColGroup).`[allColsUpTo][SingleColumn.allColsUpTo]`(someColumn) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsOf][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[Int][Int]`>().`[allUpTo][ColumnSet.allUpTo]`(Type::someColumn) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "someColGroup".`[allColsUpTo][kotlin.String.allColsUpTo]`(myColumn) }`
+     *
+     * #### Flavors of All (Cols):
+     *
+     * - [`all(Cols)`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allCols]`()`:
+     *     All columns
+     *
+     * - [`all(Cols)Before`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsBefore]`(column)`:
+     *     All columns before the specified column, excluding that column
+     *
+     * - [`all(Cols)After`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsAfter]`(column)`:
+     *     All columns after the specified column, excluding that column
+     *
+     * - [`all(Cols)From`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsFrom]`(column)`:
+     *     All columns from the specified column, including that column
+     *
+     * - [`all(Cols)UpTo`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsUpTo]`(column)`:
+     *     All columns up to the specified column, including that column
+     *
+     * @return A new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns up to [column], including [column] itself.
+     * @see [allBefore]
+     * @see [allAfter]
+     * @see [allFrom]
+     * @see [allUpTo]
+     * @see [ColumnsSelectionDsl.allExcept]
+     * @see [all]
+     * @see [cols]
+     * @param [column] The specified column up to which all columns should be taken. This column can be referenced
+     *   to both relatively to the current [ColumnsResolver][org.jetbrains.kotlinx.dataframe.columns.ColumnsResolver] and absolutely.
+     */
+    public fun String.allColsUpTo(column: AnyColumnReference): ColumnSet<*> = columnGroup(this).allColsUpTo(column)
+
+    /** ## All (Cols) Up To
+     *
+     * Creates a new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] that contains a subset of columns from [this],
+     * containing all columns up to [column], including [column] itself.
+     *
+     * [column] can be specified both relative to the current [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup] or the outer scope and
+     * can be referenced using any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi].
+     *
+     * If [column] does not exist, the function will return a [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns.
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * NOTE: Using the `{}` overloads of these functions requires a [ColumnSelector][org.jetbrains.kotlinx.dataframe.ColumnSelector]
+     * in the Plain DSL and on [column groups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     * On [ColumnSets][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] it requires a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter] instead.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[allUpTo][ColumnsSelectionDsl.allUpTo]`("someColumn") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup]`(Type::myColGroup).`[allColsUpTo][SingleColumn.allColsUpTo]`(someColumn) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsOf][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[Int][Int]`>().`[allUpTo][ColumnSet.allUpTo]`(Type::someColumn) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "someColGroup".`[allColsUpTo][kotlin.String.allColsUpTo]`(Type::myColumn) }`
+     *
+     * #### Flavors of All (Cols):
+     *
+     * - [`all(Cols)`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allCols]`()`:
+     *     All columns
+     *
+     * - [`all(Cols)Before`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsBefore]`(column)`:
+     *     All columns before the specified column, excluding that column
+     *
+     * - [`all(Cols)After`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsAfter]`(column)`:
+     *     All columns after the specified column, excluding that column
+     *
+     * - [`all(Cols)From`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsFrom]`(column)`:
+     *     All columns from the specified column, including that column
+     *
+     * - [`all(Cols)UpTo`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsUpTo]`(column)`:
+     *     All columns up to the specified column, including that column
+     *
+     * @return A new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns up to [column], including [column] itself.
+     * @see [allBefore]
+     * @see [allAfter]
+     * @see [allFrom]
+     * @see [allUpTo]
+     * @see [ColumnsSelectionDsl.allExcept]
+     * @see [all]
+     * @see [cols]
+     * @param [column] The specified column up to which all columns should be taken. This column can be referenced
+     *   to both relatively to the current [ColumnsResolver][org.jetbrains.kotlinx.dataframe.columns.ColumnsResolver] and absolutely.
+     */
+    public fun String.allColsUpTo(column: KProperty<*>): ColumnSet<*> = columnGroup(this).allColsUpTo(column)
+
+    /**
+     * ## All (Cols) Up To
+     *
+     * Creates a new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] that contains a subset of columns from [this],
+     * containing all columns up to [column], including [column] itself.
+     *
+     * [column] can be specified both relative to the current [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup] or the outer scope and
+     * can be referenced using any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi].
+     *
+     * If [column] does not exist, the function will return a [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns.
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * NOTE: Using the `{}` overloads of these functions requires a [ColumnSelector][org.jetbrains.kotlinx.dataframe.ColumnSelector]
+     * in the Plain DSL and on [column groups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     * On [ColumnSets][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] it requires a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter] instead.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[allUpTo][ColumnsSelectionDsl.allUpTo]`("someColumn") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup]`(Type::myColGroup).`[allColsUpTo][SingleColumn.allColsUpTo]`(someColumn) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsOf][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[Int][Int]`>().`[allUpTo][ColumnSet.allUpTo]`(Type::someColumn) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { DataSchemaType::someColGroup.`[allColsUpTo][kotlin.reflect.KProperty.allColsUpTo]` { myColumn } }`
+     *
+     * #### Flavors of All (Cols):
+     *
+     * - [`all(Cols)`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allCols]`()`:
+     *     All columns
+     *
+     * - [`all(Cols)Before`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsBefore]`(column)`:
+     *     All columns before the specified column, excluding that column
+     *
+     * - [`all(Cols)After`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsAfter]`(column)`:
+     *     All columns after the specified column, excluding that column
+     *
+     * - [`all(Cols)From`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsFrom]`(column)`:
+     *     All columns from the specified column, including that column
+     *
+     * - [`all(Cols)UpTo`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsUpTo]`(column)`:
+     *     All columns up to the specified column, including that column
+     *
+     * @return A new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns up to [column], including [column] itself.
+     * @see [allBefore]
+     * @see [allAfter]
+     * @see [allFrom]
+     * @see [allUpTo]
+     * @see [ColumnsSelectionDsl.allExcept]
+     * @see [all]
+     * @see [cols]
+     * @param [column] The specified column up to which all columns should be taken. This column can be referenced
+     *   to both relatively to the current [ColumnsResolver][org.jetbrains.kotlinx.dataframe.columns.ColumnsResolver] and absolutely.
+     */
+    public fun <C> KProperty<C>.allColsUpTo(column: ColumnSelector<C, *>): ColumnSet<*> =
+        columnGroup(this).allColsUpTo(column)
+
+    /** ## All (Cols) Up To
+     *
+     * Creates a new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] that contains a subset of columns from [this],
+     * containing all columns up to [column], including [column] itself.
+     *
+     * [column] can be specified both relative to the current [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup] or the outer scope and
+     * can be referenced using any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi].
+     *
+     * If [column] does not exist, the function will return a [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns.
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * NOTE: Using the `{}` overloads of these functions requires a [ColumnSelector][org.jetbrains.kotlinx.dataframe.ColumnSelector]
+     * in the Plain DSL and on [column groups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     * On [ColumnSets][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] it requires a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter] instead.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[allUpTo][ColumnsSelectionDsl.allUpTo]`("someColumn") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup]`(Type::myColGroup).`[allColsUpTo][SingleColumn.allColsUpTo]`(someColumn) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsOf][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[Int][Int]`>().`[allUpTo][ColumnSet.allUpTo]`(Type::someColumn) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { DataSchemaType::someColGroup.`[allColsUpTo][kotlin.reflect.KProperty.allColsUpTo]`("pathTo"["myColumn"]) }`
+     *
+     * #### Flavors of All (Cols):
+     *
+     * - [`all(Cols)`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allCols]`()`:
+     *     All columns
+     *
+     * - [`all(Cols)Before`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsBefore]`(column)`:
+     *     All columns before the specified column, excluding that column
+     *
+     * - [`all(Cols)After`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsAfter]`(column)`:
+     *     All columns after the specified column, excluding that column
+     *
+     * - [`all(Cols)From`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsFrom]`(column)`:
+     *     All columns from the specified column, including that column
+     *
+     * - [`all(Cols)UpTo`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsUpTo]`(column)`:
+     *     All columns up to the specified column, including that column
+     *
+     * @return A new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns up to [column], including [column] itself.
+     * @see [allBefore]
+     * @see [allAfter]
+     * @see [allFrom]
+     * @see [allUpTo]
+     * @see [ColumnsSelectionDsl.allExcept]
+     * @see [all]
+     * @see [cols]
+     * @param [column] The specified column up to which all columns should be taken. This column can be referenced
+     *   to both relatively to the current [ColumnsResolver][org.jetbrains.kotlinx.dataframe.columns.ColumnsResolver] and absolutely.
+     */
+    public fun KProperty<*>.allColsUpTo(column: ColumnPath): ColumnSet<*> = columnGroup(this).allColsUpTo(column)
+
+    /** ## All (Cols) Up To
+     *
+     * Creates a new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] that contains a subset of columns from [this],
+     * containing all columns up to [column], including [column] itself.
+     *
+     * [column] can be specified both relative to the current [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup] or the outer scope and
+     * can be referenced using any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi].
+     *
+     * If [column] does not exist, the function will return a [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns.
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * NOTE: Using the `{}` overloads of these functions requires a [ColumnSelector][org.jetbrains.kotlinx.dataframe.ColumnSelector]
+     * in the Plain DSL and on [column groups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     * On [ColumnSets][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] it requires a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter] instead.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[allUpTo][ColumnsSelectionDsl.allUpTo]`("someColumn") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup]`(Type::myColGroup).`[allColsUpTo][SingleColumn.allColsUpTo]`(someColumn) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsOf][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[Int][Int]`>().`[allUpTo][ColumnSet.allUpTo]`(Type::someColumn) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { DataSchemaType::someColGroup.`[allColsUpTo][kotlin.reflect.KProperty.allColsUpTo]`("myColumn") }`
+     *
+     * #### Flavors of All (Cols):
+     *
+     * - [`all(Cols)`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allCols]`()`:
+     *     All columns
+     *
+     * - [`all(Cols)Before`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsBefore]`(column)`:
+     *     All columns before the specified column, excluding that column
+     *
+     * - [`all(Cols)After`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsAfter]`(column)`:
+     *     All columns after the specified column, excluding that column
+     *
+     * - [`all(Cols)From`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsFrom]`(column)`:
+     *     All columns from the specified column, including that column
+     *
+     * - [`all(Cols)UpTo`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsUpTo]`(column)`:
+     *     All columns up to the specified column, including that column
+     *
+     * @return A new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns up to [column], including [column] itself.
+     * @see [allBefore]
+     * @see [allAfter]
+     * @see [allFrom]
+     * @see [allUpTo]
+     * @see [ColumnsSelectionDsl.allExcept]
+     * @see [all]
+     * @see [cols]
+     * @param [column] The specified column up to which all columns should be taken. This column can be referenced
+     *   to both relatively to the current [ColumnsResolver][org.jetbrains.kotlinx.dataframe.columns.ColumnsResolver] and absolutely.
+     */
+    public fun KProperty<*>.allColsUpTo(column: String): ColumnSet<*> = columnGroup(this).allColsUpTo(column)
+
+    /** ## All (Cols) Up To
+     *
+     * Creates a new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] that contains a subset of columns from [this],
+     * containing all columns up to [column], including [column] itself.
+     *
+     * [column] can be specified both relative to the current [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup] or the outer scope and
+     * can be referenced using any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi].
+     *
+     * If [column] does not exist, the function will return a [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns.
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * NOTE: Using the `{}` overloads of these functions requires a [ColumnSelector][org.jetbrains.kotlinx.dataframe.ColumnSelector]
+     * in the Plain DSL and on [column groups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     * On [ColumnSets][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] it requires a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter] instead.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[allUpTo][ColumnsSelectionDsl.allUpTo]`("someColumn") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup]`(Type::myColGroup).`[allColsUpTo][SingleColumn.allColsUpTo]`(someColumn) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsOf][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[Int][Int]`>().`[allUpTo][ColumnSet.allUpTo]`(Type::someColumn) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { DataSchemaType::someColGroup.`[allColsUpTo][kotlin.reflect.KProperty.allColsUpTo]`(myColumn) }`
+     *
+     * #### Flavors of All (Cols):
+     *
+     * - [`all(Cols)`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allCols]`()`:
+     *     All columns
+     *
+     * - [`all(Cols)Before`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsBefore]`(column)`:
+     *     All columns before the specified column, excluding that column
+     *
+     * - [`all(Cols)After`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsAfter]`(column)`:
+     *     All columns after the specified column, excluding that column
+     *
+     * - [`all(Cols)From`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsFrom]`(column)`:
+     *     All columns from the specified column, including that column
+     *
+     * - [`all(Cols)UpTo`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsUpTo]`(column)`:
+     *     All columns up to the specified column, including that column
+     *
+     * @return A new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns up to [column], including [column] itself.
+     * @see [allBefore]
+     * @see [allAfter]
+     * @see [allFrom]
+     * @see [allUpTo]
+     * @see [ColumnsSelectionDsl.allExcept]
+     * @see [all]
+     * @see [cols]
+     * @param [column] The specified column up to which all columns should be taken. This column can be referenced
+     *   to both relatively to the current [ColumnsResolver][org.jetbrains.kotlinx.dataframe.columns.ColumnsResolver] and absolutely.
+     */
+    public fun KProperty<*>.allColsUpTo(column: AnyColumnReference): ColumnSet<*> =
+        columnGroup(this).allColsUpTo(column)
+
+    /** ## All (Cols) Up To
+     *
+     * Creates a new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] that contains a subset of columns from [this],
+     * containing all columns up to [column], including [column] itself.
+     *
+     * [column] can be specified both relative to the current [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup] or the outer scope and
+     * can be referenced using any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi].
+     *
+     * If [column] does not exist, the function will return a [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns.
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * NOTE: Using the `{}` overloads of these functions requires a [ColumnSelector][org.jetbrains.kotlinx.dataframe.ColumnSelector]
+     * in the Plain DSL and on [column groups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     * On [ColumnSets][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] it requires a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter] instead.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[allUpTo][ColumnsSelectionDsl.allUpTo]`("someColumn") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup]`(Type::myColGroup).`[allColsUpTo][SingleColumn.allColsUpTo]`(someColumn) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsOf][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[Int][Int]`>().`[allUpTo][ColumnSet.allUpTo]`(Type::someColumn) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { DataSchemaType::someColGroup.`[allColsUpTo][kotlin.reflect.KProperty.allColsUpTo]`(Type::myColumn) }`
+     *
+     * #### Flavors of All (Cols):
+     *
+     * - [`all(Cols)`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allCols]`()`:
+     *     All columns
+     *
+     * - [`all(Cols)Before`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsBefore]`(column)`:
+     *     All columns before the specified column, excluding that column
+     *
+     * - [`all(Cols)After`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsAfter]`(column)`:
+     *     All columns after the specified column, excluding that column
+     *
+     * - [`all(Cols)From`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsFrom]`(column)`:
+     *     All columns from the specified column, including that column
+     *
+     * - [`all(Cols)UpTo`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsUpTo]`(column)`:
+     *     All columns up to the specified column, including that column
+     *
+     * @return A new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns up to [column], including [column] itself.
+     * @see [allBefore]
+     * @see [allAfter]
+     * @see [allFrom]
+     * @see [allUpTo]
+     * @see [ColumnsSelectionDsl.allExcept]
+     * @see [all]
+     * @see [cols]
+     * @param [column] The specified column up to which all columns should be taken. This column can be referenced
+     *   to both relatively to the current [ColumnsResolver][org.jetbrains.kotlinx.dataframe.columns.ColumnsResolver] and absolutely.
+     */
+    public fun KProperty<*>.allColsUpTo(column: KProperty<*>): ColumnSet<*> = columnGroup(this).allColsUpTo(column)
+
+    /** ## All (Cols) Up To
+     *
+     * Creates a new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] that contains a subset of columns from [this],
+     * containing all columns up to [column], including [column] itself.
+     *
+     * [column] can be specified both relative to the current [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup] or the outer scope and
+     * can be referenced using any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi].
+     *
+     * If [column] does not exist, the function will return a [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns.
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * NOTE: Using the `{}` overloads of these functions requires a [ColumnSelector][org.jetbrains.kotlinx.dataframe.ColumnSelector]
+     * in the Plain DSL and on [column groups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     * On [ColumnSets][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] it requires a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter] instead.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[allUpTo][ColumnsSelectionDsl.allUpTo]`("someColumn") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup]`(Type::myColGroup).`[allColsUpTo][SingleColumn.allColsUpTo]`(someColumn) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsOf][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[Int][Int]`>().`[allUpTo][ColumnSet.allUpTo]`(Type::someColumn) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "pathTo"["someColGroup"].`[allColsUpTo][org.jetbrains.kotlinx.dataframe.columns.ColumnPath.allColsUpTo]` { myColumn } }`
+     *
+     * #### Flavors of All (Cols):
+     *
+     * - [`all(Cols)`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allCols]`()`:
+     *     All columns
+     *
+     * - [`all(Cols)Before`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsBefore]`(column)`:
+     *     All columns before the specified column, excluding that column
+     *
+     * - [`all(Cols)After`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsAfter]`(column)`:
+     *     All columns after the specified column, excluding that column
+     *
+     * - [`all(Cols)From`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsFrom]`(column)`:
+     *     All columns from the specified column, including that column
+     *
+     * - [`all(Cols)UpTo`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsUpTo]`(column)`:
+     *     All columns up to the specified column, including that column
+     *
+     * @return A new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns up to [column], including [column] itself.
+     * @see [allBefore]
+     * @see [allAfter]
+     * @see [allFrom]
+     * @see [allUpTo]
+     * @see [ColumnsSelectionDsl.allExcept]
+     * @see [all]
+     * @see [cols]
+     * @param [column] The specified column up to which all columns should be taken. This column can be referenced
+     *   to both relatively to the current [ColumnsResolver][org.jetbrains.kotlinx.dataframe.columns.ColumnsResolver] and absolutely.
+     */
+    public fun ColumnPath.allColsUpTo(column: ColumnSelector<*, *>): ColumnSet<*> =
+        columnGroup(this).allColsUpTo(column)
+
+    /** ## All (Cols) Up To
+     *
+     * Creates a new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] that contains a subset of columns from [this],
+     * containing all columns up to [column], including [column] itself.
+     *
+     * [column] can be specified both relative to the current [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup] or the outer scope and
+     * can be referenced using any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi].
+     *
+     * If [column] does not exist, the function will return a [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns.
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * NOTE: Using the `{}` overloads of these functions requires a [ColumnSelector][org.jetbrains.kotlinx.dataframe.ColumnSelector]
+     * in the Plain DSL and on [column groups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     * On [ColumnSets][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] it requires a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter] instead.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[allUpTo][ColumnsSelectionDsl.allUpTo]`("someColumn") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup]`(Type::myColGroup).`[allColsUpTo][SingleColumn.allColsUpTo]`(someColumn) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsOf][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[Int][Int]`>().`[allUpTo][ColumnSet.allUpTo]`(Type::someColumn) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "pathTo"["someColGroup"].`[allColsUpTo][org.jetbrains.kotlinx.dataframe.columns.ColumnPath.allColsUpTo]`("pathTo"["myColumn"]) }`
+     *
+     * #### Flavors of All (Cols):
+     *
+     * - [`all(Cols)`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allCols]`()`:
+     *     All columns
+     *
+     * - [`all(Cols)Before`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsBefore]`(column)`:
+     *     All columns before the specified column, excluding that column
+     *
+     * - [`all(Cols)After`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsAfter]`(column)`:
+     *     All columns after the specified column, excluding that column
+     *
+     * - [`all(Cols)From`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsFrom]`(column)`:
+     *     All columns from the specified column, including that column
+     *
+     * - [`all(Cols)UpTo`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsUpTo]`(column)`:
+     *     All columns up to the specified column, including that column
+     *
+     * @return A new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns up to [column], including [column] itself.
+     * @see [allBefore]
+     * @see [allAfter]
+     * @see [allFrom]
+     * @see [allUpTo]
+     * @see [ColumnsSelectionDsl.allExcept]
+     * @see [all]
+     * @see [cols]
+     * @param [column] The specified column up to which all columns should be taken. This column can be referenced
+     *   to both relatively to the current [ColumnsResolver][org.jetbrains.kotlinx.dataframe.columns.ColumnsResolver] and absolutely.
+     */
+    public fun ColumnPath.allColsUpTo(column: ColumnPath): ColumnSet<*> = columnGroup(this).allColsUpTo(column)
+
+    /** ## All (Cols) Up To
+     *
+     * Creates a new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] that contains a subset of columns from [this],
+     * containing all columns up to [column], including [column] itself.
+     *
+     * [column] can be specified both relative to the current [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup] or the outer scope and
+     * can be referenced using any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi].
+     *
+     * If [column] does not exist, the function will return a [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns.
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * NOTE: Using the `{}` overloads of these functions requires a [ColumnSelector][org.jetbrains.kotlinx.dataframe.ColumnSelector]
+     * in the Plain DSL and on [column groups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     * On [ColumnSets][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] it requires a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter] instead.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[allUpTo][ColumnsSelectionDsl.allUpTo]`("someColumn") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup]`(Type::myColGroup).`[allColsUpTo][SingleColumn.allColsUpTo]`(someColumn) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsOf][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[Int][Int]`>().`[allUpTo][ColumnSet.allUpTo]`(Type::someColumn) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "pathTo"["someColGroup"].`[allColsUpTo][org.jetbrains.kotlinx.dataframe.columns.ColumnPath.allColsUpTo]`("myColumn") }`
+     *
+     * #### Flavors of All (Cols):
+     *
+     * - [`all(Cols)`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allCols]`()`:
+     *     All columns
+     *
+     * - [`all(Cols)Before`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsBefore]`(column)`:
+     *     All columns before the specified column, excluding that column
+     *
+     * - [`all(Cols)After`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsAfter]`(column)`:
+     *     All columns after the specified column, excluding that column
+     *
+     * - [`all(Cols)From`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsFrom]`(column)`:
+     *     All columns from the specified column, including that column
+     *
+     * - [`all(Cols)UpTo`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsUpTo]`(column)`:
+     *     All columns up to the specified column, including that column
+     *
+     * @return A new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns up to [column], including [column] itself.
+     * @see [allBefore]
+     * @see [allAfter]
+     * @see [allFrom]
+     * @see [allUpTo]
+     * @see [ColumnsSelectionDsl.allExcept]
+     * @see [all]
+     * @see [cols]
+     * @param [column] The specified column up to which all columns should be taken. This column can be referenced
+     *   to both relatively to the current [ColumnsResolver][org.jetbrains.kotlinx.dataframe.columns.ColumnsResolver] and absolutely.
+     */
+    public fun ColumnPath.allColsUpTo(column: String): ColumnSet<*> = columnGroup(this).allColsUpTo(column)
+
+    /** ## All (Cols) Up To
+     *
+     * Creates a new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] that contains a subset of columns from [this],
+     * containing all columns up to [column], including [column] itself.
+     *
+     * [column] can be specified both relative to the current [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup] or the outer scope and
+     * can be referenced using any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi].
+     *
+     * If [column] does not exist, the function will return a [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns.
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * NOTE: Using the `{}` overloads of these functions requires a [ColumnSelector][org.jetbrains.kotlinx.dataframe.ColumnSelector]
+     * in the Plain DSL and on [column groups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     * On [ColumnSets][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] it requires a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter] instead.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[allUpTo][ColumnsSelectionDsl.allUpTo]`("someColumn") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup]`(Type::myColGroup).`[allColsUpTo][SingleColumn.allColsUpTo]`(someColumn) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsOf][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[Int][Int]`>().`[allUpTo][ColumnSet.allUpTo]`(Type::someColumn) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "pathTo"["someColGroup"].`[allColsUpTo][org.jetbrains.kotlinx.dataframe.columns.ColumnPath.allColsUpTo]`(myColumn) }`
+     *
+     * #### Flavors of All (Cols):
+     *
+     * - [`all(Cols)`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allCols]`()`:
+     *     All columns
+     *
+     * - [`all(Cols)Before`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsBefore]`(column)`:
+     *     All columns before the specified column, excluding that column
+     *
+     * - [`all(Cols)After`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsAfter]`(column)`:
+     *     All columns after the specified column, excluding that column
+     *
+     * - [`all(Cols)From`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsFrom]`(column)`:
+     *     All columns from the specified column, including that column
+     *
+     * - [`all(Cols)UpTo`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsUpTo]`(column)`:
+     *     All columns up to the specified column, including that column
+     *
+     * @return A new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns up to [column], including [column] itself.
+     * @see [allBefore]
+     * @see [allAfter]
+     * @see [allFrom]
+     * @see [allUpTo]
+     * @see [ColumnsSelectionDsl.allExcept]
+     * @see [all]
+     * @see [cols]
+     * @param [column] The specified column up to which all columns should be taken. This column can be referenced
+     *   to both relatively to the current [ColumnsResolver][org.jetbrains.kotlinx.dataframe.columns.ColumnsResolver] and absolutely.
+     */
+    public fun ColumnPath.allColsUpTo(column: AnyColumnReference): ColumnSet<*> = columnGroup(this).allColsUpTo(column)
+
+    /** ## All (Cols) Up To
+     *
+     * Creates a new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] that contains a subset of columns from [this],
+     * containing all columns up to [column], including [column] itself.
+     *
+     * [column] can be specified both relative to the current [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup] or the outer scope and
+     * can be referenced using any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi].
+     *
+     * If [column] does not exist, the function will return a [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns.
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * NOTE: Using the `{}` overloads of these functions requires a [ColumnSelector][org.jetbrains.kotlinx.dataframe.ColumnSelector]
+     * in the Plain DSL and on [column groups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     * On [ColumnSets][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] it requires a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter] instead.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[allUpTo][ColumnsSelectionDsl.allUpTo]`("someColumn") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup]`(Type::myColGroup).`[allColsUpTo][SingleColumn.allColsUpTo]`(someColumn) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsOf][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[Int][Int]`>().`[allUpTo][ColumnSet.allUpTo]`(Type::someColumn) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "pathTo"["someColGroup"].`[allColsUpTo][org.jetbrains.kotlinx.dataframe.columns.ColumnPath.allColsUpTo]`(Type::myColumn) }`
+     *
+     * #### Flavors of All (Cols):
+     *
+     * - [`all(Cols)`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allCols]`()`:
+     *     All columns
+     *
+     * - [`all(Cols)Before`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsBefore]`(column)`:
+     *     All columns before the specified column, excluding that column
+     *
+     * - [`all(Cols)After`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsAfter]`(column)`:
+     *     All columns after the specified column, excluding that column
+     *
+     * - [`all(Cols)From`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsFrom]`(column)`:
+     *     All columns from the specified column, including that column
+     *
+     * - [`all(Cols)UpTo`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allColsUpTo]`(column)`:
+     *     All columns up to the specified column, including that column
+     *
+     * @return A new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns up to [column], including [column] itself.
+     * @see [allBefore]
+     * @see [allAfter]
+     * @see [allFrom]
+     * @see [allUpTo]
+     * @see [ColumnsSelectionDsl.allExcept]
+     * @see [all]
+     * @see [cols]
+     * @param [column] The specified column up to which all columns should be taken. This column can be referenced
+     *   to both relatively to the current [ColumnsResolver][org.jetbrains.kotlinx.dataframe.columns.ColumnsResolver] and absolutely.
+     */
+    public fun ColumnPath.allColsUpTo(column: KProperty<*>): ColumnSet<*> = columnGroup(this).allColsUpTo(column)
+
+    // endregion
+}
+
+/**
+ * If [this] is a [SingleColumn] containing a single [ColumnGroup], it
+ * returns a [(transformable) ColumnSet][TransformableColumnSet] containing the children of this [ColumnGroup],
+ * else it simply returns a [(transformable) ColumnSet][TransformableColumnSet] from [this].
+ */
+internal fun ColumnsResolver<*>.allColumnsInternal(removePaths: Boolean = false): TransformableColumnSet<*> =
+    transform {
+        if (isSingleColumnWithGroup(it)) {
+            it.single().let {
+                if (removePaths) {
+                    it.asColumnGroup().columns().map(AnyCol::addPath)
+                } else {
+                    it.cols()
+                }
+            }
+        } else {
+            it
+        }
+    }
+
+/**
+ * Returns a new ColumnSet containing all columns after the first column that matches the given predicate.
+ *
+ * @param colByPredicate a function that takes a ColumnWithPath and returns true if the column matches the predicate, false otherwise
+ * @return a new ColumnSet containing all columns after the first column that matches the given predicate
+ */
+internal fun ColumnsResolver<*>.allAfterInternal(colByPredicate: ColumnFilter<*>): ColumnSet<*> {
+    var take = false
+    return colsInternal {
+        if (take) {
+            true
+        } else {
+            take = colByPredicate(it)
+            false
+        }
+    }
+}
+
+/**
+ * Returns a column set containing all columns from the internal column set that satisfy the given predicate.
+ *
+ * @param colByPredicate the predicate used to determine if a column should be included in the resulting set
+ * @return a column set containing all columns that satisfy the predicate
+ */
+internal fun ColumnsResolver<*>.allFromInternal(colByPredicate: ColumnFilter<*>): ColumnSet<*> {
+    var take = false
+    return colsInternal {
+        if (take) {
+            true
+        } else {
+            take = colByPredicate(it)
+            take
+        }
+    }
+}
+
+/**
+ * Returns a new ColumnSet containing all columns before the first column that satisfies the given predicate.
+ *
+ * @param colByPredicate the predicate function used to determine if a column should be included in the returned ColumnSet
+ * @return a new ColumnSet containing all columns that come before the first column that satisfies the given predicate
+ */
+internal fun ColumnsResolver<*>.allBeforeInternal(colByPredicate: ColumnFilter<*>): ColumnSet<*> {
+    var take = true
+    return colsInternal {
+        if (!take) {
+            false
+        } else {
+            take = !colByPredicate(it)
+            take
+        }
+    }
+}
+
+/**
+ * Returns a ColumnSet containing all columns up to (and including) the first column that satisfies the given predicate.
+ *
+ * @param colByPredicate a predicate function that takes a ColumnWithPath and returns true if the column satisfies the desired condition.
+ * @return a ColumnSet containing all columns up to the first column that satisfies the given predicate.
+ */
+internal fun ColumnsResolver<*>.allUpToInternal(colByPredicate: ColumnFilter<*>): ColumnSet<*> {
+    var take = true
+    return colsInternal {
+        if (!take) {
+            false
+        } else {
+            take = !colByPredicate(it)
+            true
+        }
+    }
+}
+
+// endregion
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/allExcept.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/allExcept.kt
new file mode 100644
index 000000000..493295e20
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/allExcept.kt
@@ -0,0 +1,4571 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import org.jetbrains.kotlinx.dataframe.ColumnsSelector
+import org.jetbrains.kotlinx.dataframe.DataColumn
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.DataRow
+import org.jetbrains.kotlinx.dataframe.columns.ColumnGroup
+import org.jetbrains.kotlinx.dataframe.columns.ColumnPath
+import org.jetbrains.kotlinx.dataframe.columns.ColumnSet
+import org.jetbrains.kotlinx.dataframe.columns.ColumnWithPath
+import org.jetbrains.kotlinx.dataframe.columns.ColumnsResolver
+import org.jetbrains.kotlinx.dataframe.columns.SingleColumn
+import org.jetbrains.kotlinx.dataframe.columns.toColumnSet
+import org.jetbrains.kotlinx.dataframe.impl.aggregation.toColumns
+import org.jetbrains.kotlinx.dataframe.impl.columns.allColumnsExceptKeepingStructure
+import org.jetbrains.kotlinx.dataframe.impl.columns.changePath
+import org.jetbrains.kotlinx.dataframe.impl.columns.createColumnSet
+import org.jetbrains.kotlinx.dataframe.impl.columns.transformSingle
+import org.jetbrains.kotlinx.dataframe.util.ALL_COLS_EXCEPT
+import org.jetbrains.kotlinx.dataframe.util.ALL_COLS_REPLACE
+import org.jetbrains.kotlinx.dataframe.util.ALL_COLS_REPLACE_VARARG
+import kotlin.reflect.KProperty
+
+// region ColumnsSelectionDsl
+
+/**
+ * ## (All) (Cols) Except [Columns Selection DSL][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl]
+ *
+ * See [Grammar] for all functions in this interface.
+ */
+public interface AllExceptColumnsSelectionDsl {
+
+    /**
+     * ## (All) (Cols) Except Grammar
+     *
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * [(What is this notation?)][org.jetbrains.kotlinx.dataframe.documentation.DslGrammar]
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  ### Definitions:
+     *  `columnSet: `[`ColumnSet`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]`<*>`
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  `columnGroup: `[`SingleColumn`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]`<`[`DataRow`][org.jetbrains.kotlinx.dataframe.DataRow]`<*>> | `[`String`][String]`  |  `[`KProperty`][kotlin.reflect.KProperty]`<* | `[`DataRow`][org.jetbrains.kotlinx.dataframe.DataRow]`<*>> | `[`ColumnPath`][org.jetbrains.kotlinx.dataframe.columns.ColumnPath]
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  `colsSelector: `[`ColumnsSelector`][org.jetbrains.kotlinx.dataframe.ColumnsSelector]
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  `column: `[`ColumnAccessor`][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor]`  |  `[`String`][String]`  | `[`KProperty`][kotlin.reflect.KProperty]`<*> | `[`ColumnPath`][org.jetbrains.kotlinx.dataframe.columns.ColumnPath]
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  `columnNoAccessor: `[`String`][String]`  |  `[`KProperty`][kotlin.reflect.KProperty]`<*> | `[`ColumnPath`][org.jetbrains.kotlinx.dataframe.columns.ColumnPath]
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  `columnsResolver: `[`ColumnsResolver`][org.jetbrains.kotlinx.dataframe.columns.ColumnsResolver]
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  ### What can be called directly in the [Columns Selection DSL][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl]:
+     *
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  [**`allExcept`**][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.allExcept]**`   {   `**[`colsSelector`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ColumnsSelectorDef]**` }`**
+     *
+     *  `| `[**`allExcept`**][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.allExcept]**`(`**[`column`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ColumnDef]**`,`**` ..`**`)`**
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  ### What can be called on a [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]:
+     *
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  [`columnSet`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ColumnSetDef]
+     *
+     *  &nbsp;&nbsp;&nbsp;&nbsp;[**`except`**][org.jetbrains.kotlinx.dataframe.api.AllExceptColumnsSelectionDsl.except]` [`**`  {  `**`] `[`columnsResolver`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ColumnsResolverDef]` [`**`  }  `**`]`
+     *
+     *  &nbsp;&nbsp;&nbsp;&nbsp;`| `[**`except`**][org.jetbrains.kotlinx.dataframe.api.AllExceptColumnsSelectionDsl.except]` `[`column`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ColumnDef]
+     *
+     *  &nbsp;&nbsp;&nbsp;&nbsp;`| `**`.`**[**`except`**][org.jetbrains.kotlinx.dataframe.api.AllExceptColumnsSelectionDsl.except]**`(`**[`column`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ColumnDef]**`,`**` ..`**`)`**
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  ### What can be called on a [Column Group (reference)][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ColumnGroupDef]:
+     *
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  [`columnGroup`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ColumnGroupDef]
+     *
+     *  &nbsp;&nbsp;&nbsp;&nbsp;__`.`__[**`allColsExcept`**][org.jetbrains.kotlinx.dataframe.api.AllExceptColumnsSelectionDsl.allColsExcept]**`  {  `**[`colsSelector`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ColumnsSelectorDef]**`  }  `**
+     *
+     *  &nbsp;&nbsp;&nbsp;&nbsp;`| `__`.`__[**`allColsExcept`**][org.jetbrains.kotlinx.dataframe.api.AllExceptColumnsSelectionDsl.allColsExcept]**`(`**[`columnNoAccessor`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ColumnNoAccessorDef]**`,`**` ..`**`)`**
+     *
+     *  &nbsp;&nbsp;&nbsp;&nbsp;`| `[**`exceptNew`**][org.jetbrains.kotlinx.dataframe.api.AllExceptColumnsSelectionDsl.exceptNew]**`  {  `**[`colsSelector`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ColumnsSelectorDef]**` } EXPERIMENTAL!`**
+     *
+     *  &nbsp;&nbsp;&nbsp;&nbsp;`| `[**`exceptNew`**][org.jetbrains.kotlinx.dataframe.api.AllExceptColumnsSelectionDsl.exceptNew]**`(`**[`columnNoAccessor`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ColumnNoAccessorDef]**`,`**` ..`**`) EXPERIMENTAL!`**
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     */
+    public interface Grammar {
+
+        /** [**`allExcept`**][ColumnsSelectionDsl.allExcept] */
+        public interface PlainDslName
+
+        /** [**`except`**][ColumnsSelectionDsl.except] */
+        public interface ColumnSetName
+
+        /** __`.`__[**`allColsExcept`**][ColumnsSelectionDsl.allColsExcept] */
+        public interface ColumnGroupName
+
+        /** [**`exceptNew`**][ColumnsSelectionDsl.exceptNew] */
+        public interface ColumnGroupExperimentalName
+    }
+
+    /**
+     * ## (All) (Cols) Except
+     *
+     * Perform a selection of columns using the [Columns Selection DSL][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl] to
+     * exclude from the current selection.
+     *
+     * ### Check out: [Grammar]
+     *
+     * ### On [ColumnSets][ColumnSet]
+     * This function can be explained the easiest with [ColumnSets][ColumnSet]. Let's say we want all
+     * [Int] columns apart from `age`  and  `height`.
+     *
+     * We can do:
+     *
+     * `df.`[select][DataFrame.select]`  {  `[colsOf][colsOf]`<`[Int][Int]`>() `[except][ColumnSet.except]`  (age  `[and][ColumnsSelectionDsl.and]` height) }`
+     *
+     * which will 'subtract' the [ColumnSet] created by `age `[and][ColumnsSelectionDsl.and]` height` from the [ColumnSet] created by [colsOf][colsOf]`<`[Int][Int]`>()`.
+     *
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * This operation can also be used to exclude columns from [Column Groups][ColumnGroup].
+     *
+     * For instance:
+     *
+     * `df.`[select][DataFrame.select]`  {  `[colsAtAnyDepth][ColumnsSelectionDsl.colsAtAnyDepth]`  { "a"  `[in][String.contains]` it.`[name][DataColumn.name]`() } `[except][ColumnSet.except]` userData.age }`
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     * Note that the selection of columns to exclude from [column sets][ColumnSet] is always done relative to the outer
+     * scope. Use the [Extension Properties API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi.ExtensionPropertiesApi] to prevent scoping issues if possible.
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * Special case: If a column that needs to be removed appears multiple times in the [ColumnSet], it is excepted
+     * each time it is encountered (including inside [ColumnGroups][ColumnGroup]). You could say the receiver [ColumnSet]
+     * is [simplified][ColumnsSelectionDsl.simplify] before the operation is performed:
+     *
+     * [cols][ColumnsSelectionDsl.cols]`(a, a, a.b, a.b).`[except][ColumnSet.except]`(a.b)`
+     *
+     * `== `[cols][ColumnsSelectionDsl.cols]`(a).`[except][ColumnSet.except]`(a.b)`
+     *
+     * ### In the [ColumnsSelectionDsl][ColumnsSelectionDsl]
+     * Instead of having to write [all][ColumnsSelectionDsl.all]`() `[except][ColumnsSelectionDsl.except]` { ... }` in the DSL,
+     * you can use [allExcept][ColumnsSelectionDsl.allExcept]` { ... }` to achieve the same result.
+     *
+     * For example:
+     *
+     * `df.`[select][DataFrame.select]`  {  `[allExcept][ColumnsSelectionDsl.allExcept]`  { userData.age  `[and][ColumnsSelectionDsl.and]` height } }`
+     *
+     * ### On [ColumnGroups][ColumnGroup]
+     * The variant of this function on [ColumnGroups][ColumnGroup] is a bit different as it changes the scope relative to
+     * the column group.
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * In other words:
+     *
+     * `df.`[select][DataFrame.select]` { myColGroup.`[allColsExcept][SingleColumn.allColsExcept]`  { colA  `[and][ColumnsSelectionDsl.and]` colB } }`
+     *
+     * is shorthand for
+     *
+     * `df.`[select][DataFrame.select]` { myColGroup.`[select][ColumnsSelectionDsl.select]`  {  `[all][ColumnsSelectionDsl.all]`() `[except][ColumnSet.except]`  { colA  `[and][ColumnsSelectionDsl.and]` colB } } }`
+     *
+     * or
+     *
+     * `df.`[select][DataFrame.select]` { myColGroup.`[allCols][ColumnsSelectionDsl.allCols]`() `[except][ColumnSet.except]`  { myColGroup.colA  `[and][ColumnsSelectionDsl.and]` myColGroup.colB } }`
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * Also note the name change, similar to [allCols][ColumnsSelectionDsl.allCols], this makes it clearer that you're selecting
+     * columns inside the group, 'lifting' them out.
+     *
+     * ### Examples for this overload
+     *
+     *
+     *
+     * @return A [ColumnSet] containing all columns in [this] except the specified ones.
+     * @see ColumnsSelectionDsl.select
+     * @see ColumnsSelectionDsl.all
+     * @see ColumnsSelectionDsl.allBefore
+     * @see ColumnsSelectionDsl.allAfter
+     * @see ColumnsSelectionDsl.allUpTo
+     * @see ColumnsSelectionDsl.allFrom
+     */
+    private interface CommonExceptDocs {
+
+        // Example argument
+        interface ExampleArg
+
+        // Parameter argument
+        interface ParamArg
+    }
+
+    // region ColumnSet
+
+    /**
+     * ## (All) (Cols) Except
+     *
+     * Perform a selection of columns using the [Columns Selection DSL][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl] to
+     * exclude from the current selection.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.AllExceptColumnsSelectionDsl.Grammar]
+     *
+     * ### On [ColumnSets][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]
+     * This function can be explained the easiest with [ColumnSets][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]. Let's say we want all
+     * [Int] columns apart from `age`  and  `height`.
+     *
+     * We can do:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsOf][org.jetbrains.kotlinx.dataframe.api.colsOf]`<`[Int][Int]`>() `[except][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.except]`  (age  `[and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]` height) }`
+     *
+     * which will 'subtract' the [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] created by `age `[and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]` height` from the [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] created by [colsOf][org.jetbrains.kotlinx.dataframe.api.colsOf]`<`[Int][Int]`>()`.
+     *
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * This operation can also be used to exclude columns from [Column Groups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * For instance:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsAtAnyDepth][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsAtAnyDepth]`  { "a"  `[in][String.contains]` it.`[name][org.jetbrains.kotlinx.dataframe.DataColumn.name]`() } `[except][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.except]` userData.age }`
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     * Note that the selection of columns to exclude from [column sets][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] is always done relative to the outer
+     * scope. Use the [Extension Properties API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi.ExtensionPropertiesApi] to prevent scoping issues if possible.
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * Special case: If a column that needs to be removed appears multiple times in the [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet], it is excepted
+     * each time it is encountered (including inside [ColumnGroups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup]). You could say the receiver [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]
+     * is [simplified][org.jetbrains.kotlinx.dataframe.api.SimplifyColumnsSelectionDsl.simplify] before the operation is performed:
+     *
+     * [cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`(a, a, a.b, a.b).`[except][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.except]`(a.b)`
+     *
+     * `== `[cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`(a).`[except][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.except]`(a.b)`
+     *
+     * ### In the [ColumnsSelectionDsl][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl]
+     * Instead of having to write [all][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.all]`() `[except][org.jetbrains.kotlinx.dataframe.api.AllExceptColumnsSelectionDsl.except]` { ... }` in the DSL,
+     * you can use [allExcept][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.allExcept]` { ... }` to achieve the same result.
+     *
+     * For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[allExcept][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.allExcept]`  { userData.age  `[and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]` height } }`
+     *
+     * ### On [ColumnGroups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup]
+     * The variant of this function on [ColumnGroups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup] is a bit different as it changes the scope relative to
+     * the column group.
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * In other words:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColGroup.`[allColsExcept][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.allColsExcept]`  { colA  `[and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]` colB } }`
+     *
+     * is shorthand for
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColGroup.`[select][org.jetbrains.kotlinx.dataframe.api.SelectColumnsSelectionDsl.select]`  {  `[all][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.all]`() `[except][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.except]`  { colA  `[and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]` colB } } }`
+     *
+     * or
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColGroup.`[allCols][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allCols]`() `[except][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.except]`  { myColGroup.colA  `[and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]` myColGroup.colB } }`
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * Also note the name change, similar to [allCols][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allCols], this makes it clearer that you're selecting
+     * columns inside the group, 'lifting' them out.
+     *
+     * ### Examples for this overload
+     * `df.`[select][ColumnsSelectionDsl.select]`  {  `[colsOf][ColumnsSelectionDsl.colsOf]`<`[Number][Number]`>() `[except][ColumnSet.except]` `` }`
+     *
+     *  `df.`[select][ColumnsSelectionDsl.select]`  {  `[cols][ColumnsSelectionDsl.cols]`(name, age) `[except][ColumnSet.except]` `` }`
+     *
+     *
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns in [this] except the specified ones.
+     * @see ColumnsSelectionDsl.select
+     * @see ColumnsSelectionDsl.all
+     * @see ColumnsSelectionDsl.allBefore
+     * @see ColumnsSelectionDsl.allAfter
+     * @see ColumnsSelectionDsl.allUpTo
+     * @see ColumnsSelectionDsl.allFrom
+     *
+     */
+    private interface ColumnSetInfixDocs {
+
+        // argument
+        interface ArgumentArg1
+
+        // argument
+        interface ArgumentArg2
+    }
+
+    /**
+     * ## (All) (Cols) Except
+     *
+     * Perform a selection of columns using the [Columns Selection DSL][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl] to
+     * exclude from the current selection.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.AllExceptColumnsSelectionDsl.Grammar]
+     *
+     * ### On [ColumnSets][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]
+     * This function can be explained the easiest with [ColumnSets][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]. Let's say we want all
+     * [Int] columns apart from `age`  and  `height`.
+     *
+     * We can do:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsOf][org.jetbrains.kotlinx.dataframe.api.colsOf]`<`[Int][Int]`>() `[except][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.except]`  (age  `[and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]` height) }`
+     *
+     * which will 'subtract' the [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] created by `age `[and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]` height` from the [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] created by [colsOf][org.jetbrains.kotlinx.dataframe.api.colsOf]`<`[Int][Int]`>()`.
+     *
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * This operation can also be used to exclude columns from [Column Groups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * For instance:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsAtAnyDepth][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsAtAnyDepth]`  { "a"  `[in][String.contains]` it.`[name][org.jetbrains.kotlinx.dataframe.DataColumn.name]`() } `[except][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.except]` userData.age }`
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     * Note that the selection of columns to exclude from [column sets][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] is always done relative to the outer
+     * scope. Use the [Extension Properties API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi.ExtensionPropertiesApi] to prevent scoping issues if possible.
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * Special case: If a column that needs to be removed appears multiple times in the [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet], it is excepted
+     * each time it is encountered (including inside [ColumnGroups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup]). You could say the receiver [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]
+     * is [simplified][org.jetbrains.kotlinx.dataframe.api.SimplifyColumnsSelectionDsl.simplify] before the operation is performed:
+     *
+     * [cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`(a, a, a.b, a.b).`[except][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.except]`(a.b)`
+     *
+     * `== `[cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`(a).`[except][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.except]`(a.b)`
+     *
+     * ### In the [ColumnsSelectionDsl][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl]
+     * Instead of having to write [all][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.all]`() `[except][org.jetbrains.kotlinx.dataframe.api.AllExceptColumnsSelectionDsl.except]` { ... }` in the DSL,
+     * you can use [allExcept][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.allExcept]` { ... }` to achieve the same result.
+     *
+     * For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[allExcept][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.allExcept]`  { userData.age  `[and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]` height } }`
+     *
+     * ### On [ColumnGroups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup]
+     * The variant of this function on [ColumnGroups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup] is a bit different as it changes the scope relative to
+     * the column group.
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * In other words:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColGroup.`[allColsExcept][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.allColsExcept]`  { colA  `[and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]` colB } }`
+     *
+     * is shorthand for
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColGroup.`[select][org.jetbrains.kotlinx.dataframe.api.SelectColumnsSelectionDsl.select]`  {  `[all][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.all]`() `[except][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.except]`  { colA  `[and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]` colB } } }`
+     *
+     * or
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColGroup.`[allCols][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allCols]`() `[except][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.except]`  { myColGroup.colA  `[and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]` myColGroup.colB } }`
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * Also note the name change, similar to [allCols][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allCols], this makes it clearer that you're selecting
+     * columns inside the group, 'lifting' them out.
+     *
+     * ### Examples for this overload
+     * `df.`[select][ColumnsSelectionDsl.select]`  {  `[colsOf][ColumnsSelectionDsl.colsOf]`<`[Number][Number]`>().`[except][ColumnSet.except]` }`
+     *
+     *  `df.`[select][ColumnsSelectionDsl.select]`  {  `[cols][ColumnsSelectionDsl.cols]`(name, age).`[except][ColumnSet.except]` }`
+     *
+     *
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns in [this] except the specified ones.
+     * @see ColumnsSelectionDsl.select
+     * @see ColumnsSelectionDsl.all
+     * @see ColumnsSelectionDsl.allBefore
+     * @see ColumnsSelectionDsl.allAfter
+     * @see ColumnsSelectionDsl.allUpTo
+     * @see ColumnsSelectionDsl.allFrom
+     *
+     */
+    private interface ColumnSetVarargDocs {
+
+        // argument
+        interface ArgumentArg1
+
+        // argument
+        interface ArgumentArg2
+    }
+
+    /**
+     * ## (All) (Cols) Except
+     *
+     * Perform a selection of columns using the [Columns Selection DSL][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl] to
+     * exclude from the current selection.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.AllExceptColumnsSelectionDsl.Grammar]
+     *
+     * ### On [ColumnSets][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]
+     * This function can be explained the easiest with [ColumnSets][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]. Let's say we want all
+     * [Int] columns apart from `age`  and  `height`.
+     *
+     * We can do:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsOf][org.jetbrains.kotlinx.dataframe.api.colsOf]`<`[Int][Int]`>() `[except][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.except]`  (age  `[and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]` height) }`
+     *
+     * which will 'subtract' the [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] created by `age `[and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]` height` from the [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] created by [colsOf][org.jetbrains.kotlinx.dataframe.api.colsOf]`<`[Int][Int]`>()`.
+     *
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * This operation can also be used to exclude columns from [Column Groups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * For instance:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsAtAnyDepth][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsAtAnyDepth]`  { "a"  `[in][String.contains]` it.`[name][org.jetbrains.kotlinx.dataframe.DataColumn.name]`() } `[except][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.except]` userData.age }`
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     * Note that the selection of columns to exclude from [column sets][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] is always done relative to the outer
+     * scope. Use the [Extension Properties API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi.ExtensionPropertiesApi] to prevent scoping issues if possible.
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * Special case: If a column that needs to be removed appears multiple times in the [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet], it is excepted
+     * each time it is encountered (including inside [ColumnGroups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup]). You could say the receiver [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]
+     * is [simplified][org.jetbrains.kotlinx.dataframe.api.SimplifyColumnsSelectionDsl.simplify] before the operation is performed:
+     *
+     * [cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`(a, a, a.b, a.b).`[except][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.except]`(a.b)`
+     *
+     * `== `[cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`(a).`[except][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.except]`(a.b)`
+     *
+     * ### In the [ColumnsSelectionDsl][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl]
+     * Instead of having to write [all][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.all]`() `[except][org.jetbrains.kotlinx.dataframe.api.AllExceptColumnsSelectionDsl.except]` { ... }` in the DSL,
+     * you can use [allExcept][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.allExcept]` { ... }` to achieve the same result.
+     *
+     * For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[allExcept][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.allExcept]`  { userData.age  `[and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]` height } }`
+     *
+     * ### On [ColumnGroups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup]
+     * The variant of this function on [ColumnGroups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup] is a bit different as it changes the scope relative to
+     * the column group.
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * In other words:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColGroup.`[allColsExcept][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.allColsExcept]`  { colA  `[and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]` colB } }`
+     *
+     * is shorthand for
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColGroup.`[select][org.jetbrains.kotlinx.dataframe.api.SelectColumnsSelectionDsl.select]`  {  `[all][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.all]`() `[except][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.except]`  { colA  `[and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]` colB } } }`
+     *
+     * or
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColGroup.`[allCols][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allCols]`() `[except][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.except]`  { myColGroup.colA  `[and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]` myColGroup.colB } }`
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * Also note the name change, similar to [allCols][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allCols], this makes it clearer that you're selecting
+     * columns inside the group, 'lifting' them out.
+     *
+     * ### Examples for this overload
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.api.SelectColumnsSelectionDsl.select]`  {  `[colsOf][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[Number][Number]`>() `[except][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.except]` ``{ "age" `[and][ColumnsSelectionDsl.and]` height }`` }`
+     *
+     *  `df.`[select][org.jetbrains.kotlinx.dataframe.api.SelectColumnsSelectionDsl.select]`  {  `[cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`(name, age) `[except][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.except]` ``{ name.firstName }`` }`
+     *
+     * @param [selector] A lambda in which you specify the columns that need to be
+     *   excluded from the [ColumnSet]. The scope of the selector is the same as the outer scope.
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns in [this] except the specified ones.
+     * @see ColumnsSelectionDsl.select
+     * @see ColumnsSelectionDsl.all
+     * @see ColumnsSelectionDsl.allBefore
+     * @see ColumnsSelectionDsl.allAfter
+     * @see ColumnsSelectionDsl.allUpTo
+     * @see ColumnsSelectionDsl.allFrom
+     *
+     */
+    public infix fun <C> ColumnSet<C>.except(selector: () -> ColumnsResolver<*>): ColumnSet<C> = except(selector())
+
+    /**
+     * ## (All) (Cols) Except
+     *
+     * Perform a selection of columns using the [Columns Selection DSL][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl] to
+     * exclude from the current selection.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.AllExceptColumnsSelectionDsl.Grammar]
+     *
+     * ### On [ColumnSets][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]
+     * This function can be explained the easiest with [ColumnSets][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]. Let's say we want all
+     * [Int] columns apart from `age`  and  `height`.
+     *
+     * We can do:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsOf][org.jetbrains.kotlinx.dataframe.api.colsOf]`<`[Int][Int]`>() `[except][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.except]`  (age  `[and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]` height) }`
+     *
+     * which will 'subtract' the [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] created by `age `[and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]` height` from the [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] created by [colsOf][org.jetbrains.kotlinx.dataframe.api.colsOf]`<`[Int][Int]`>()`.
+     *
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * This operation can also be used to exclude columns from [Column Groups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * For instance:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsAtAnyDepth][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsAtAnyDepth]`  { "a"  `[in][String.contains]` it.`[name][org.jetbrains.kotlinx.dataframe.DataColumn.name]`() } `[except][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.except]` userData.age }`
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     * Note that the selection of columns to exclude from [column sets][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] is always done relative to the outer
+     * scope. Use the [Extension Properties API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi.ExtensionPropertiesApi] to prevent scoping issues if possible.
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * Special case: If a column that needs to be removed appears multiple times in the [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet], it is excepted
+     * each time it is encountered (including inside [ColumnGroups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup]). You could say the receiver [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]
+     * is [simplified][org.jetbrains.kotlinx.dataframe.api.SimplifyColumnsSelectionDsl.simplify] before the operation is performed:
+     *
+     * [cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`(a, a, a.b, a.b).`[except][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.except]`(a.b)`
+     *
+     * `== `[cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`(a).`[except][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.except]`(a.b)`
+     *
+     * ### In the [ColumnsSelectionDsl][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl]
+     * Instead of having to write [all][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.all]`() `[except][org.jetbrains.kotlinx.dataframe.api.AllExceptColumnsSelectionDsl.except]` { ... }` in the DSL,
+     * you can use [allExcept][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.allExcept]` { ... }` to achieve the same result.
+     *
+     * For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[allExcept][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.allExcept]`  { userData.age  `[and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]` height } }`
+     *
+     * ### On [ColumnGroups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup]
+     * The variant of this function on [ColumnGroups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup] is a bit different as it changes the scope relative to
+     * the column group.
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * In other words:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColGroup.`[allColsExcept][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.allColsExcept]`  { colA  `[and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]` colB } }`
+     *
+     * is shorthand for
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColGroup.`[select][org.jetbrains.kotlinx.dataframe.api.SelectColumnsSelectionDsl.select]`  {  `[all][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.all]`() `[except][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.except]`  { colA  `[and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]` colB } } }`
+     *
+     * or
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColGroup.`[allCols][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allCols]`() `[except][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.except]`  { myColGroup.colA  `[and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]` myColGroup.colB } }`
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * Also note the name change, similar to [allCols][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allCols], this makes it clearer that you're selecting
+     * columns inside the group, 'lifting' them out.
+     *
+     * ### Examples for this overload
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.api.SelectColumnsSelectionDsl.select]`  {  `[colsOf][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[Number][Number]`>() `[except][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.except]` ``"age" `[and][ColumnsSelectionDsl.and]` height`` }`
+     *
+     *  `df.`[select][org.jetbrains.kotlinx.dataframe.api.SelectColumnsSelectionDsl.select]`  {  `[cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`(name, age) `[except][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.except]` ``name.firstName`` }`
+     *
+     * @param [other] A [ColumnsResolver] containing the columns that need to be
+     *   excluded from the [ColumnSet].
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns in [this] except the specified ones.
+     * @see ColumnsSelectionDsl.select
+     * @see ColumnsSelectionDsl.all
+     * @see ColumnsSelectionDsl.allBefore
+     * @see ColumnsSelectionDsl.allAfter
+     * @see ColumnsSelectionDsl.allUpTo
+     * @see ColumnsSelectionDsl.allFrom
+     *
+     */
+    public infix fun <C> ColumnSet<C>.except(other: ColumnsResolver<*>): ColumnSet<C> = exceptInternal(other)
+
+    /**
+     * ## (All) (Cols) Except
+     *
+     * Perform a selection of columns using the [Columns Selection DSL][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl] to
+     * exclude from the current selection.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.AllExceptColumnsSelectionDsl.Grammar]
+     *
+     * ### On [ColumnSets][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]
+     * This function can be explained the easiest with [ColumnSets][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]. Let's say we want all
+     * [Int] columns apart from `age`  and  `height`.
+     *
+     * We can do:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsOf][org.jetbrains.kotlinx.dataframe.api.colsOf]`<`[Int][Int]`>() `[except][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.except]`  (age  `[and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]` height) }`
+     *
+     * which will 'subtract' the [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] created by `age `[and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]` height` from the [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] created by [colsOf][org.jetbrains.kotlinx.dataframe.api.colsOf]`<`[Int][Int]`>()`.
+     *
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * This operation can also be used to exclude columns from [Column Groups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * For instance:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsAtAnyDepth][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsAtAnyDepth]`  { "a"  `[in][String.contains]` it.`[name][org.jetbrains.kotlinx.dataframe.DataColumn.name]`() } `[except][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.except]` userData.age }`
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     * Note that the selection of columns to exclude from [column sets][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] is always done relative to the outer
+     * scope. Use the [Extension Properties API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi.ExtensionPropertiesApi] to prevent scoping issues if possible.
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * Special case: If a column that needs to be removed appears multiple times in the [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet], it is excepted
+     * each time it is encountered (including inside [ColumnGroups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup]). You could say the receiver [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]
+     * is [simplified][org.jetbrains.kotlinx.dataframe.api.SimplifyColumnsSelectionDsl.simplify] before the operation is performed:
+     *
+     * [cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`(a, a, a.b, a.b).`[except][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.except]`(a.b)`
+     *
+     * `== `[cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`(a).`[except][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.except]`(a.b)`
+     *
+     * ### In the [ColumnsSelectionDsl][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl]
+     * Instead of having to write [all][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.all]`() `[except][org.jetbrains.kotlinx.dataframe.api.AllExceptColumnsSelectionDsl.except]` { ... }` in the DSL,
+     * you can use [allExcept][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.allExcept]` { ... }` to achieve the same result.
+     *
+     * For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[allExcept][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.allExcept]`  { userData.age  `[and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]` height } }`
+     *
+     * ### On [ColumnGroups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup]
+     * The variant of this function on [ColumnGroups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup] is a bit different as it changes the scope relative to
+     * the column group.
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * In other words:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColGroup.`[allColsExcept][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.allColsExcept]`  { colA  `[and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]` colB } }`
+     *
+     * is shorthand for
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColGroup.`[select][org.jetbrains.kotlinx.dataframe.api.SelectColumnsSelectionDsl.select]`  {  `[all][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.all]`() `[except][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.except]`  { colA  `[and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]` colB } } }`
+     *
+     * or
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColGroup.`[allCols][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allCols]`() `[except][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.except]`  { myColGroup.colA  `[and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]` myColGroup.colB } }`
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * Also note the name change, similar to [allCols][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allCols], this makes it clearer that you're selecting
+     * columns inside the group, 'lifting' them out.
+     *
+     * ### Examples for this overload
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.api.SelectColumnsSelectionDsl.select]`  {  `[colsOf][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[Number][Number]`>().`[except][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.except]`(age, userData.height)`` }`
+     *
+     *  `df.`[select][org.jetbrains.kotlinx.dataframe.api.SelectColumnsSelectionDsl.select]`  {  `[cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`(name, age).`[except][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.except]`(name.firstName, name.middleName)`` }`
+     *
+     * @param [others] Any number of [ColumnsResolvers][ColumnsResolver] containing
+     *  the columns that need to be excluded from the [ColumnSet].
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns in [this] except the specified ones.
+     * @see ColumnsSelectionDsl.select
+     * @see ColumnsSelectionDsl.all
+     * @see ColumnsSelectionDsl.allBefore
+     * @see ColumnsSelectionDsl.allAfter
+     * @see ColumnsSelectionDsl.allUpTo
+     * @see ColumnsSelectionDsl.allFrom
+     *
+     */
+    public fun <C> ColumnSet<C>.except(vararg others: ColumnsResolver<*>): ColumnSet<C> = except(others.toColumnSet())
+
+    /**
+     * ## (All) (Cols) Except
+     *
+     * Perform a selection of columns using the [Columns Selection DSL][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl] to
+     * exclude from the current selection.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.AllExceptColumnsSelectionDsl.Grammar]
+     *
+     * ### On [ColumnSets][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]
+     * This function can be explained the easiest with [ColumnSets][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]. Let's say we want all
+     * [Int] columns apart from `age`  and  `height`.
+     *
+     * We can do:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsOf][org.jetbrains.kotlinx.dataframe.api.colsOf]`<`[Int][Int]`>() `[except][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.except]`  (age  `[and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]` height) }`
+     *
+     * which will 'subtract' the [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] created by `age `[and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]` height` from the [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] created by [colsOf][org.jetbrains.kotlinx.dataframe.api.colsOf]`<`[Int][Int]`>()`.
+     *
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * This operation can also be used to exclude columns from [Column Groups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * For instance:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsAtAnyDepth][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsAtAnyDepth]`  { "a"  `[in][String.contains]` it.`[name][org.jetbrains.kotlinx.dataframe.DataColumn.name]`() } `[except][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.except]` userData.age }`
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     * Note that the selection of columns to exclude from [column sets][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] is always done relative to the outer
+     * scope. Use the [Extension Properties API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi.ExtensionPropertiesApi] to prevent scoping issues if possible.
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * Special case: If a column that needs to be removed appears multiple times in the [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet], it is excepted
+     * each time it is encountered (including inside [ColumnGroups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup]). You could say the receiver [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]
+     * is [simplified][org.jetbrains.kotlinx.dataframe.api.SimplifyColumnsSelectionDsl.simplify] before the operation is performed:
+     *
+     * [cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`(a, a, a.b, a.b).`[except][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.except]`(a.b)`
+     *
+     * `== `[cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`(a).`[except][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.except]`(a.b)`
+     *
+     * ### In the [ColumnsSelectionDsl][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl]
+     * Instead of having to write [all][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.all]`() `[except][org.jetbrains.kotlinx.dataframe.api.AllExceptColumnsSelectionDsl.except]` { ... }` in the DSL,
+     * you can use [allExcept][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.allExcept]` { ... }` to achieve the same result.
+     *
+     * For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[allExcept][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.allExcept]`  { userData.age  `[and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]` height } }`
+     *
+     * ### On [ColumnGroups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup]
+     * The variant of this function on [ColumnGroups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup] is a bit different as it changes the scope relative to
+     * the column group.
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * In other words:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColGroup.`[allColsExcept][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.allColsExcept]`  { colA  `[and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]` colB } }`
+     *
+     * is shorthand for
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColGroup.`[select][org.jetbrains.kotlinx.dataframe.api.SelectColumnsSelectionDsl.select]`  {  `[all][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.all]`() `[except][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.except]`  { colA  `[and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]` colB } } }`
+     *
+     * or
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColGroup.`[allCols][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allCols]`() `[except][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.except]`  { myColGroup.colA  `[and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]` myColGroup.colB } }`
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * Also note the name change, similar to [allCols][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allCols], this makes it clearer that you're selecting
+     * columns inside the group, 'lifting' them out.
+     *
+     * ### Examples for this overload
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.api.SelectColumnsSelectionDsl.select]`  {  `[colsOf][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[Number][Number]`>() `[except][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.except]` ``"age"`` }`
+     *
+     *  `df.`[select][org.jetbrains.kotlinx.dataframe.api.SelectColumnsSelectionDsl.select]`  {  `[cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`(name, age) `[except][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.except]` ``"name"`` }`
+     *
+     * @param [other] A [String] referring to
+     *  the column (relative to the current scope) that needs to be excluded from the [ColumnSet].
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns in [this] except the specified ones.
+     * @see ColumnsSelectionDsl.select
+     * @see ColumnsSelectionDsl.all
+     * @see ColumnsSelectionDsl.allBefore
+     * @see ColumnsSelectionDsl.allAfter
+     * @see ColumnsSelectionDsl.allUpTo
+     * @see ColumnsSelectionDsl.allFrom
+     *
+     */
+    public infix fun <C> ColumnSet<C>.except(other: String): ColumnSet<C> = except(column<Any?>(other))
+
+    /**
+     * ## (All) (Cols) Except
+     *
+     * Perform a selection of columns using the [Columns Selection DSL][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl] to
+     * exclude from the current selection.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.AllExceptColumnsSelectionDsl.Grammar]
+     *
+     * ### On [ColumnSets][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]
+     * This function can be explained the easiest with [ColumnSets][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]. Let's say we want all
+     * [Int] columns apart from `age`  and  `height`.
+     *
+     * We can do:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsOf][org.jetbrains.kotlinx.dataframe.api.colsOf]`<`[Int][Int]`>() `[except][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.except]`  (age  `[and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]` height) }`
+     *
+     * which will 'subtract' the [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] created by `age `[and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]` height` from the [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] created by [colsOf][org.jetbrains.kotlinx.dataframe.api.colsOf]`<`[Int][Int]`>()`.
+     *
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * This operation can also be used to exclude columns from [Column Groups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * For instance:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsAtAnyDepth][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsAtAnyDepth]`  { "a"  `[in][String.contains]` it.`[name][org.jetbrains.kotlinx.dataframe.DataColumn.name]`() } `[except][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.except]` userData.age }`
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     * Note that the selection of columns to exclude from [column sets][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] is always done relative to the outer
+     * scope. Use the [Extension Properties API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi.ExtensionPropertiesApi] to prevent scoping issues if possible.
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * Special case: If a column that needs to be removed appears multiple times in the [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet], it is excepted
+     * each time it is encountered (including inside [ColumnGroups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup]). You could say the receiver [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]
+     * is [simplified][org.jetbrains.kotlinx.dataframe.api.SimplifyColumnsSelectionDsl.simplify] before the operation is performed:
+     *
+     * [cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`(a, a, a.b, a.b).`[except][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.except]`(a.b)`
+     *
+     * `== `[cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`(a).`[except][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.except]`(a.b)`
+     *
+     * ### In the [ColumnsSelectionDsl][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl]
+     * Instead of having to write [all][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.all]`() `[except][org.jetbrains.kotlinx.dataframe.api.AllExceptColumnsSelectionDsl.except]` { ... }` in the DSL,
+     * you can use [allExcept][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.allExcept]` { ... }` to achieve the same result.
+     *
+     * For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[allExcept][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.allExcept]`  { userData.age  `[and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]` height } }`
+     *
+     * ### On [ColumnGroups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup]
+     * The variant of this function on [ColumnGroups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup] is a bit different as it changes the scope relative to
+     * the column group.
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * In other words:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColGroup.`[allColsExcept][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.allColsExcept]`  { colA  `[and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]` colB } }`
+     *
+     * is shorthand for
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColGroup.`[select][org.jetbrains.kotlinx.dataframe.api.SelectColumnsSelectionDsl.select]`  {  `[all][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.all]`() `[except][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.except]`  { colA  `[and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]` colB } } }`
+     *
+     * or
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColGroup.`[allCols][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allCols]`() `[except][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.except]`  { myColGroup.colA  `[and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]` myColGroup.colB } }`
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * Also note the name change, similar to [allCols][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allCols], this makes it clearer that you're selecting
+     * columns inside the group, 'lifting' them out.
+     *
+     * ### Examples for this overload
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.api.SelectColumnsSelectionDsl.select]`  {  `[colsOf][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[Number][Number]`>().`[except][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.except]`("age", "height")`` }`
+     *
+     *  `df.`[select][org.jetbrains.kotlinx.dataframe.api.SelectColumnsSelectionDsl.select]`  {  `[cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`(name, age).`[except][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.except]`("name")`` }`
+     *
+     * @param [others] Any number of [Strings][String] referring to
+     *  the columns (relative to the current scope) that need to be excluded from the [ColumnSet].
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns in [this] except the specified ones.
+     * @see ColumnsSelectionDsl.select
+     * @see ColumnsSelectionDsl.all
+     * @see ColumnsSelectionDsl.allBefore
+     * @see ColumnsSelectionDsl.allAfter
+     * @see ColumnsSelectionDsl.allUpTo
+     * @see ColumnsSelectionDsl.allFrom
+     *
+     */
+    public fun <C> ColumnSet<C>.except(vararg others: String): ColumnSet<C> = except(others.toColumnSet())
+
+    /**
+     * ## (All) (Cols) Except
+     *
+     * Perform a selection of columns using the [Columns Selection DSL][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl] to
+     * exclude from the current selection.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.AllExceptColumnsSelectionDsl.Grammar]
+     *
+     * ### On [ColumnSets][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]
+     * This function can be explained the easiest with [ColumnSets][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]. Let's say we want all
+     * [Int] columns apart from `age`  and  `height`.
+     *
+     * We can do:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsOf][org.jetbrains.kotlinx.dataframe.api.colsOf]`<`[Int][Int]`>() `[except][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.except]`  (age  `[and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]` height) }`
+     *
+     * which will 'subtract' the [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] created by `age `[and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]` height` from the [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] created by [colsOf][org.jetbrains.kotlinx.dataframe.api.colsOf]`<`[Int][Int]`>()`.
+     *
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * This operation can also be used to exclude columns from [Column Groups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * For instance:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsAtAnyDepth][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsAtAnyDepth]`  { "a"  `[in][String.contains]` it.`[name][org.jetbrains.kotlinx.dataframe.DataColumn.name]`() } `[except][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.except]` userData.age }`
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     * Note that the selection of columns to exclude from [column sets][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] is always done relative to the outer
+     * scope. Use the [Extension Properties API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi.ExtensionPropertiesApi] to prevent scoping issues if possible.
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * Special case: If a column that needs to be removed appears multiple times in the [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet], it is excepted
+     * each time it is encountered (including inside [ColumnGroups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup]). You could say the receiver [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]
+     * is [simplified][org.jetbrains.kotlinx.dataframe.api.SimplifyColumnsSelectionDsl.simplify] before the operation is performed:
+     *
+     * [cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`(a, a, a.b, a.b).`[except][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.except]`(a.b)`
+     *
+     * `== `[cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`(a).`[except][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.except]`(a.b)`
+     *
+     * ### In the [ColumnsSelectionDsl][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl]
+     * Instead of having to write [all][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.all]`() `[except][org.jetbrains.kotlinx.dataframe.api.AllExceptColumnsSelectionDsl.except]` { ... }` in the DSL,
+     * you can use [allExcept][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.allExcept]` { ... }` to achieve the same result.
+     *
+     * For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[allExcept][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.allExcept]`  { userData.age  `[and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]` height } }`
+     *
+     * ### On [ColumnGroups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup]
+     * The variant of this function on [ColumnGroups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup] is a bit different as it changes the scope relative to
+     * the column group.
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * In other words:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColGroup.`[allColsExcept][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.allColsExcept]`  { colA  `[and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]` colB } }`
+     *
+     * is shorthand for
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColGroup.`[select][org.jetbrains.kotlinx.dataframe.api.SelectColumnsSelectionDsl.select]`  {  `[all][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.all]`() `[except][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.except]`  { colA  `[and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]` colB } } }`
+     *
+     * or
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColGroup.`[allCols][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allCols]`() `[except][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.except]`  { myColGroup.colA  `[and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]` myColGroup.colB } }`
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * Also note the name change, similar to [allCols][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allCols], this makes it clearer that you're selecting
+     * columns inside the group, 'lifting' them out.
+     *
+     * ### Examples for this overload
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.api.SelectColumnsSelectionDsl.select]`  {  `[colsOf][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[Number][Number]`>() `[except][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.except]` ``Person::age`` }`
+     *
+     *  `df.`[select][org.jetbrains.kotlinx.dataframe.api.SelectColumnsSelectionDsl.select]`  {  `[cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`(name, age) `[except][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.except]` ``Person::name`` }`
+     *
+     * @param [other] A [KProperty] referring to
+     *  the column (relative to the current scope) that needs to be excluded from the [ColumnSet].
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns in [this] except the specified ones.
+     * @see ColumnsSelectionDsl.select
+     * @see ColumnsSelectionDsl.all
+     * @see ColumnsSelectionDsl.allBefore
+     * @see ColumnsSelectionDsl.allAfter
+     * @see ColumnsSelectionDsl.allUpTo
+     * @see ColumnsSelectionDsl.allFrom
+     *
+     */
+    public infix fun <C> ColumnSet<C>.except(other: KProperty<C>): ColumnSet<C> = except(column(other))
+
+    /**
+     * ## (All) (Cols) Except
+     *
+     * Perform a selection of columns using the [Columns Selection DSL][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl] to
+     * exclude from the current selection.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.AllExceptColumnsSelectionDsl.Grammar]
+     *
+     * ### On [ColumnSets][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]
+     * This function can be explained the easiest with [ColumnSets][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]. Let's say we want all
+     * [Int] columns apart from `age`  and  `height`.
+     *
+     * We can do:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsOf][org.jetbrains.kotlinx.dataframe.api.colsOf]`<`[Int][Int]`>() `[except][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.except]`  (age  `[and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]` height) }`
+     *
+     * which will 'subtract' the [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] created by `age `[and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]` height` from the [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] created by [colsOf][org.jetbrains.kotlinx.dataframe.api.colsOf]`<`[Int][Int]`>()`.
+     *
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * This operation can also be used to exclude columns from [Column Groups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * For instance:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsAtAnyDepth][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsAtAnyDepth]`  { "a"  `[in][String.contains]` it.`[name][org.jetbrains.kotlinx.dataframe.DataColumn.name]`() } `[except][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.except]` userData.age }`
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     * Note that the selection of columns to exclude from [column sets][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] is always done relative to the outer
+     * scope. Use the [Extension Properties API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi.ExtensionPropertiesApi] to prevent scoping issues if possible.
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * Special case: If a column that needs to be removed appears multiple times in the [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet], it is excepted
+     * each time it is encountered (including inside [ColumnGroups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup]). You could say the receiver [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]
+     * is [simplified][org.jetbrains.kotlinx.dataframe.api.SimplifyColumnsSelectionDsl.simplify] before the operation is performed:
+     *
+     * [cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`(a, a, a.b, a.b).`[except][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.except]`(a.b)`
+     *
+     * `== `[cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`(a).`[except][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.except]`(a.b)`
+     *
+     * ### In the [ColumnsSelectionDsl][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl]
+     * Instead of having to write [all][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.all]`() `[except][org.jetbrains.kotlinx.dataframe.api.AllExceptColumnsSelectionDsl.except]` { ... }` in the DSL,
+     * you can use [allExcept][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.allExcept]` { ... }` to achieve the same result.
+     *
+     * For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[allExcept][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.allExcept]`  { userData.age  `[and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]` height } }`
+     *
+     * ### On [ColumnGroups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup]
+     * The variant of this function on [ColumnGroups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup] is a bit different as it changes the scope relative to
+     * the column group.
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * In other words:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColGroup.`[allColsExcept][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.allColsExcept]`  { colA  `[and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]` colB } }`
+     *
+     * is shorthand for
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColGroup.`[select][org.jetbrains.kotlinx.dataframe.api.SelectColumnsSelectionDsl.select]`  {  `[all][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.all]`() `[except][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.except]`  { colA  `[and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]` colB } } }`
+     *
+     * or
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColGroup.`[allCols][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allCols]`() `[except][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.except]`  { myColGroup.colA  `[and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]` myColGroup.colB } }`
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * Also note the name change, similar to [allCols][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allCols], this makes it clearer that you're selecting
+     * columns inside the group, 'lifting' them out.
+     *
+     * ### Examples for this overload
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.api.SelectColumnsSelectionDsl.select]`  {  `[colsOf][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[Number][Number]`>().`[except][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.except]`(Person::age, Person::height)`` }`
+     *
+     *  `df.`[select][org.jetbrains.kotlinx.dataframe.api.SelectColumnsSelectionDsl.select]`  {  `[cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`(name, age).`[except][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.except]`(Person::name)`` }`
+     *
+     * @param [others] Any number of [KProperties][KProperty] referring to
+     *  the columns (relative to the current scope) that need to be excluded from the [ColumnSet].
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns in [this] except the specified ones.
+     * @see ColumnsSelectionDsl.select
+     * @see ColumnsSelectionDsl.all
+     * @see ColumnsSelectionDsl.allBefore
+     * @see ColumnsSelectionDsl.allAfter
+     * @see ColumnsSelectionDsl.allUpTo
+     * @see ColumnsSelectionDsl.allFrom
+     *
+     */
+    public fun <C> ColumnSet<C>.except(vararg others: KProperty<C>): ColumnSet<C> = except(others.toColumnSet())
+
+    /**
+     * ## (All) (Cols) Except
+     *
+     * Perform a selection of columns using the [Columns Selection DSL][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl] to
+     * exclude from the current selection.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.AllExceptColumnsSelectionDsl.Grammar]
+     *
+     * ### On [ColumnSets][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]
+     * This function can be explained the easiest with [ColumnSets][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]. Let's say we want all
+     * [Int] columns apart from `age`  and  `height`.
+     *
+     * We can do:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsOf][org.jetbrains.kotlinx.dataframe.api.colsOf]`<`[Int][Int]`>() `[except][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.except]`  (age  `[and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]` height) }`
+     *
+     * which will 'subtract' the [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] created by `age `[and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]` height` from the [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] created by [colsOf][org.jetbrains.kotlinx.dataframe.api.colsOf]`<`[Int][Int]`>()`.
+     *
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * This operation can also be used to exclude columns from [Column Groups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * For instance:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsAtAnyDepth][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsAtAnyDepth]`  { "a"  `[in][String.contains]` it.`[name][org.jetbrains.kotlinx.dataframe.DataColumn.name]`() } `[except][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.except]` userData.age }`
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     * Note that the selection of columns to exclude from [column sets][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] is always done relative to the outer
+     * scope. Use the [Extension Properties API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi.ExtensionPropertiesApi] to prevent scoping issues if possible.
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * Special case: If a column that needs to be removed appears multiple times in the [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet], it is excepted
+     * each time it is encountered (including inside [ColumnGroups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup]). You could say the receiver [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]
+     * is [simplified][org.jetbrains.kotlinx.dataframe.api.SimplifyColumnsSelectionDsl.simplify] before the operation is performed:
+     *
+     * [cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`(a, a, a.b, a.b).`[except][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.except]`(a.b)`
+     *
+     * `== `[cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`(a).`[except][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.except]`(a.b)`
+     *
+     * ### In the [ColumnsSelectionDsl][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl]
+     * Instead of having to write [all][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.all]`() `[except][org.jetbrains.kotlinx.dataframe.api.AllExceptColumnsSelectionDsl.except]` { ... }` in the DSL,
+     * you can use [allExcept][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.allExcept]` { ... }` to achieve the same result.
+     *
+     * For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[allExcept][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.allExcept]`  { userData.age  `[and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]` height } }`
+     *
+     * ### On [ColumnGroups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup]
+     * The variant of this function on [ColumnGroups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup] is a bit different as it changes the scope relative to
+     * the column group.
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * In other words:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColGroup.`[allColsExcept][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.allColsExcept]`  { colA  `[and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]` colB } }`
+     *
+     * is shorthand for
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColGroup.`[select][org.jetbrains.kotlinx.dataframe.api.SelectColumnsSelectionDsl.select]`  {  `[all][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.all]`() `[except][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.except]`  { colA  `[and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]` colB } } }`
+     *
+     * or
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColGroup.`[allCols][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allCols]`() `[except][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.except]`  { myColGroup.colA  `[and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]` myColGroup.colB } }`
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * Also note the name change, similar to [allCols][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allCols], this makes it clearer that you're selecting
+     * columns inside the group, 'lifting' them out.
+     *
+     * ### Examples for this overload
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.api.SelectColumnsSelectionDsl.select]`  {  `[colsOf][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[Number][Number]`>() `[except][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.except]` ``"userdata"["age"]`` }`
+     *
+     *  `df.`[select][org.jetbrains.kotlinx.dataframe.api.SelectColumnsSelectionDsl.select]`  {  `[cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`(name, age) `[except][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.except]` ``pathOf("name", "firstName")`` }`
+     *
+     * @param [other] A [ColumnPath] referring to
+     *  the column (relative to the current scope) that needs to be excluded from the [ColumnSet].
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns in [this] except the specified ones.
+     * @see ColumnsSelectionDsl.select
+     * @see ColumnsSelectionDsl.all
+     * @see ColumnsSelectionDsl.allBefore
+     * @see ColumnsSelectionDsl.allAfter
+     * @see ColumnsSelectionDsl.allUpTo
+     * @see ColumnsSelectionDsl.allFrom
+     *
+     */
+    public infix fun <C> ColumnSet<C>.except(other: ColumnPath): ColumnSet<C> = except(column<Any?>(other))
+
+    /**
+     * ## (All) (Cols) Except
+     *
+     * Perform a selection of columns using the [Columns Selection DSL][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl] to
+     * exclude from the current selection.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.AllExceptColumnsSelectionDsl.Grammar]
+     *
+     * ### On [ColumnSets][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]
+     * This function can be explained the easiest with [ColumnSets][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]. Let's say we want all
+     * [Int] columns apart from `age`  and  `height`.
+     *
+     * We can do:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsOf][org.jetbrains.kotlinx.dataframe.api.colsOf]`<`[Int][Int]`>() `[except][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.except]`  (age  `[and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]` height) }`
+     *
+     * which will 'subtract' the [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] created by `age `[and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]` height` from the [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] created by [colsOf][org.jetbrains.kotlinx.dataframe.api.colsOf]`<`[Int][Int]`>()`.
+     *
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * This operation can also be used to exclude columns from [Column Groups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * For instance:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsAtAnyDepth][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsAtAnyDepth]`  { "a"  `[in][String.contains]` it.`[name][org.jetbrains.kotlinx.dataframe.DataColumn.name]`() } `[except][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.except]` userData.age }`
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     * Note that the selection of columns to exclude from [column sets][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] is always done relative to the outer
+     * scope. Use the [Extension Properties API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi.ExtensionPropertiesApi] to prevent scoping issues if possible.
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * Special case: If a column that needs to be removed appears multiple times in the [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet], it is excepted
+     * each time it is encountered (including inside [ColumnGroups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup]). You could say the receiver [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]
+     * is [simplified][org.jetbrains.kotlinx.dataframe.api.SimplifyColumnsSelectionDsl.simplify] before the operation is performed:
+     *
+     * [cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`(a, a, a.b, a.b).`[except][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.except]`(a.b)`
+     *
+     * `== `[cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`(a).`[except][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.except]`(a.b)`
+     *
+     * ### In the [ColumnsSelectionDsl][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl]
+     * Instead of having to write [all][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.all]`() `[except][org.jetbrains.kotlinx.dataframe.api.AllExceptColumnsSelectionDsl.except]` { ... }` in the DSL,
+     * you can use [allExcept][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.allExcept]` { ... }` to achieve the same result.
+     *
+     * For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[allExcept][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.allExcept]`  { userData.age  `[and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]` height } }`
+     *
+     * ### On [ColumnGroups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup]
+     * The variant of this function on [ColumnGroups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup] is a bit different as it changes the scope relative to
+     * the column group.
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * In other words:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColGroup.`[allColsExcept][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.allColsExcept]`  { colA  `[and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]` colB } }`
+     *
+     * is shorthand for
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColGroup.`[select][org.jetbrains.kotlinx.dataframe.api.SelectColumnsSelectionDsl.select]`  {  `[all][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.all]`() `[except][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.except]`  { colA  `[and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]` colB } } }`
+     *
+     * or
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColGroup.`[allCols][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allCols]`() `[except][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.except]`  { myColGroup.colA  `[and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]` myColGroup.colB } }`
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * Also note the name change, similar to [allCols][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allCols], this makes it clearer that you're selecting
+     * columns inside the group, 'lifting' them out.
+     *
+     * ### Examples for this overload
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.api.SelectColumnsSelectionDsl.select]`  {  `[colsOf][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[Number][Number]`>().`[except][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.except]`(pathOf("age"), "userdata"["height"])`` }`
+     *
+     *  `df.`[select][org.jetbrains.kotlinx.dataframe.api.SelectColumnsSelectionDsl.select]`  {  `[cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`(name, age).`[except][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.except]`("name"["firstName"], "name"["middleName"])`` }`
+     *
+     * @param [others] Any number of [ColumnPaths][ColumnPath] referring to
+     *  the columns (relative to the current scope) that need to be excluded from the [ColumnSet].
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns in [this] except the specified ones.
+     * @see ColumnsSelectionDsl.select
+     * @see ColumnsSelectionDsl.all
+     * @see ColumnsSelectionDsl.allBefore
+     * @see ColumnsSelectionDsl.allAfter
+     * @see ColumnsSelectionDsl.allUpTo
+     * @see ColumnsSelectionDsl.allFrom
+     *
+     */
+    public fun <C> ColumnSet<C>.except(vararg others: ColumnPath): ColumnSet<C> = except(others.toColumnSet())
+
+    // endregion
+
+    // region ColumnsSelectionDsl
+
+    /**
+     * ## (All) (Cols) Except
+     *
+     * Perform a selection of columns using the [Columns Selection DSL][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl] to
+     * exclude from the current selection.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.AllExceptColumnsSelectionDsl.Grammar]
+     *
+     * ### On [ColumnSets][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]
+     * This function can be explained the easiest with [ColumnSets][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]. Let's say we want all
+     * [Int] columns apart from `age`  and  `height`.
+     *
+     * We can do:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsOf][org.jetbrains.kotlinx.dataframe.api.colsOf]`<`[Int][Int]`>() `[except][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.except]`  (age  `[and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]` height) }`
+     *
+     * which will 'subtract' the [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] created by `age `[and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]` height` from the [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] created by [colsOf][org.jetbrains.kotlinx.dataframe.api.colsOf]`<`[Int][Int]`>()`.
+     *
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * This operation can also be used to exclude columns from [Column Groups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * For instance:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsAtAnyDepth][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsAtAnyDepth]`  { "a"  `[in][String.contains]` it.`[name][org.jetbrains.kotlinx.dataframe.DataColumn.name]`() } `[except][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.except]` userData.age }`
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     * Note that the selection of columns to exclude from [column sets][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] is always done relative to the outer
+     * scope. Use the [Extension Properties API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi.ExtensionPropertiesApi] to prevent scoping issues if possible.
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * Special case: If a column that needs to be removed appears multiple times in the [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet], it is excepted
+     * each time it is encountered (including inside [ColumnGroups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup]). You could say the receiver [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]
+     * is [simplified][org.jetbrains.kotlinx.dataframe.api.SimplifyColumnsSelectionDsl.simplify] before the operation is performed:
+     *
+     * [cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`(a, a, a.b, a.b).`[except][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.except]`(a.b)`
+     *
+     * `== `[cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`(a).`[except][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.except]`(a.b)`
+     *
+     * ### In the [ColumnsSelectionDsl][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl]
+     * Instead of having to write [all][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.all]`() `[except][org.jetbrains.kotlinx.dataframe.api.AllExceptColumnsSelectionDsl.except]` { ... }` in the DSL,
+     * you can use [allExcept][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.allExcept]` { ... }` to achieve the same result.
+     *
+     * For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[allExcept][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.allExcept]`  { userData.age  `[and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]` height } }`
+     *
+     * ### On [ColumnGroups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup]
+     * The variant of this function on [ColumnGroups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup] is a bit different as it changes the scope relative to
+     * the column group.
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * In other words:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColGroup.`[allColsExcept][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.allColsExcept]`  { colA  `[and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]` colB } }`
+     *
+     * is shorthand for
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColGroup.`[select][org.jetbrains.kotlinx.dataframe.api.SelectColumnsSelectionDsl.select]`  {  `[all][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.all]`() `[except][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.except]`  { colA  `[and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]` colB } } }`
+     *
+     * or
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColGroup.`[allCols][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allCols]`() `[except][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.except]`  { myColGroup.colA  `[and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]` myColGroup.colB } }`
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * Also note the name change, similar to [allCols][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allCols], this makes it clearer that you're selecting
+     * columns inside the group, 'lifting' them out.
+     *
+     * ### Examples for this overload
+     * `df.`[select][ColumnsSelectionDsl.select]`  {  `[allExcept][ColumnsSelectionDsl.allExcept]` }`
+     *
+     *  `df.`[select][ColumnsSelectionDsl.select]`  {  `[allExcept][ColumnsSelectionDsl.allExcept]` }`
+     *
+     *
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns in [this] except the specified ones.
+     * @see ColumnsSelectionDsl.select
+     * @see ColumnsSelectionDsl.all
+     * @see ColumnsSelectionDsl.allBefore
+     * @see ColumnsSelectionDsl.allAfter
+     * @see ColumnsSelectionDsl.allUpTo
+     * @see ColumnsSelectionDsl.allFrom
+     */
+    private interface ColumnsSelectionDslDocs {
+
+        // argument
+        interface ArgumentArg1
+
+        // argument
+        interface ArgumentArg2
+    }
+
+    /**
+     * ## (All) (Cols) Except
+     *
+     * Perform a selection of columns using the [Columns Selection DSL][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl] to
+     * exclude from the current selection.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.AllExceptColumnsSelectionDsl.Grammar]
+     *
+     * ### On [ColumnSets][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]
+     * This function can be explained the easiest with [ColumnSets][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]. Let's say we want all
+     * [Int] columns apart from `age`  and  `height`.
+     *
+     * We can do:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsOf][org.jetbrains.kotlinx.dataframe.api.colsOf]`<`[Int][Int]`>() `[except][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.except]`  (age  `[and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]` height) }`
+     *
+     * which will 'subtract' the [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] created by `age `[and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]` height` from the [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] created by [colsOf][org.jetbrains.kotlinx.dataframe.api.colsOf]`<`[Int][Int]`>()`.
+     *
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * This operation can also be used to exclude columns from [Column Groups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * For instance:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsAtAnyDepth][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsAtAnyDepth]`  { "a"  `[in][String.contains]` it.`[name][org.jetbrains.kotlinx.dataframe.DataColumn.name]`() } `[except][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.except]` userData.age }`
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     * Note that the selection of columns to exclude from [column sets][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] is always done relative to the outer
+     * scope. Use the [Extension Properties API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi.ExtensionPropertiesApi] to prevent scoping issues if possible.
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * Special case: If a column that needs to be removed appears multiple times in the [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet], it is excepted
+     * each time it is encountered (including inside [ColumnGroups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup]). You could say the receiver [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]
+     * is [simplified][org.jetbrains.kotlinx.dataframe.api.SimplifyColumnsSelectionDsl.simplify] before the operation is performed:
+     *
+     * [cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`(a, a, a.b, a.b).`[except][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.except]`(a.b)`
+     *
+     * `== `[cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`(a).`[except][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.except]`(a.b)`
+     *
+     * ### In the [ColumnsSelectionDsl][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl]
+     * Instead of having to write [all][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.all]`() `[except][org.jetbrains.kotlinx.dataframe.api.AllExceptColumnsSelectionDsl.except]` { ... }` in the DSL,
+     * you can use [allExcept][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.allExcept]` { ... }` to achieve the same result.
+     *
+     * For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[allExcept][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.allExcept]`  { userData.age  `[and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]` height } }`
+     *
+     * ### On [ColumnGroups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup]
+     * The variant of this function on [ColumnGroups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup] is a bit different as it changes the scope relative to
+     * the column group.
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * In other words:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColGroup.`[allColsExcept][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.allColsExcept]`  { colA  `[and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]` colB } }`
+     *
+     * is shorthand for
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColGroup.`[select][org.jetbrains.kotlinx.dataframe.api.SelectColumnsSelectionDsl.select]`  {  `[all][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.all]`() `[except][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.except]`  { colA  `[and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]` colB } } }`
+     *
+     * or
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColGroup.`[allCols][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allCols]`() `[except][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.except]`  { myColGroup.colA  `[and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]` myColGroup.colB } }`
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * Also note the name change, similar to [allCols][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allCols], this makes it clearer that you're selecting
+     * columns inside the group, 'lifting' them out.
+     *
+     * ### Examples for this overload
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.api.SelectColumnsSelectionDsl.select]`  {  `[allExcept][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.allExcept]`  { "age"  `[and][ColumnsSelectionDsl.and]` height }`` }`
+     *
+     *  `df.`[select][org.jetbrains.kotlinx.dataframe.api.SelectColumnsSelectionDsl.select]`  {  `[allExcept][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.allExcept]` { name.firstName }`` }`
+     *
+     * @param [selector] A lambda in which you specify the columns that need to be
+     *  excluded from the current selection. The scope of the selector is the same as the outer scope.
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns in [this] except the specified ones.
+     * @see ColumnsSelectionDsl.select
+     * @see ColumnsSelectionDsl.all
+     * @see ColumnsSelectionDsl.allBefore
+     * @see ColumnsSelectionDsl.allAfter
+     * @see ColumnsSelectionDsl.allUpTo
+     * @see ColumnsSelectionDsl.allFrom
+     */
+    public fun <C> ColumnsSelectionDsl<C>.allExcept(selector: ColumnsSelector<C, *>): ColumnSet<*> =
+        this.asSingleColumn().allColsExcept(selector)
+
+    /**
+     *
+     * ## (All) (Cols) Except
+     *
+     * Perform a selection of columns using the [Columns Selection DSL][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl] to
+     * exclude from the current selection.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.AllExceptColumnsSelectionDsl.Grammar]
+     *
+     * ### On [ColumnSets][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]
+     * This function can be explained the easiest with [ColumnSets][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]. Let's say we want all
+     * [Int] columns apart from `age`  and  `height`.
+     *
+     * We can do:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsOf][org.jetbrains.kotlinx.dataframe.api.colsOf]`<`[Int][Int]`>() `[except][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.except]`  (age  `[and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]` height) }`
+     *
+     * which will 'subtract' the [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] created by `age `[and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]` height` from the [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] created by [colsOf][org.jetbrains.kotlinx.dataframe.api.colsOf]`<`[Int][Int]`>()`.
+     *
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * This operation can also be used to exclude columns from [Column Groups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * For instance:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsAtAnyDepth][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsAtAnyDepth]`  { "a"  `[in][String.contains]` it.`[name][org.jetbrains.kotlinx.dataframe.DataColumn.name]`() } `[except][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.except]` userData.age }`
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     * Note that the selection of columns to exclude from [column sets][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] is always done relative to the outer
+     * scope. Use the [Extension Properties API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi.ExtensionPropertiesApi] to prevent scoping issues if possible.
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * Special case: If a column that needs to be removed appears multiple times in the [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet], it is excepted
+     * each time it is encountered (including inside [ColumnGroups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup]). You could say the receiver [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]
+     * is [simplified][org.jetbrains.kotlinx.dataframe.api.SimplifyColumnsSelectionDsl.simplify] before the operation is performed:
+     *
+     * [cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`(a, a, a.b, a.b).`[except][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.except]`(a.b)`
+     *
+     * `== `[cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`(a).`[except][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.except]`(a.b)`
+     *
+     * ### In the [ColumnsSelectionDsl][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl]
+     * Instead of having to write [all][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.all]`() `[except][org.jetbrains.kotlinx.dataframe.api.AllExceptColumnsSelectionDsl.except]` { ... }` in the DSL,
+     * you can use [allExcept][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.allExcept]` { ... }` to achieve the same result.
+     *
+     * For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[allExcept][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.allExcept]`  { userData.age  `[and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]` height } }`
+     *
+     * ### On [ColumnGroups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup]
+     * The variant of this function on [ColumnGroups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup] is a bit different as it changes the scope relative to
+     * the column group.
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * In other words:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColGroup.`[allColsExcept][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.allColsExcept]`  { colA  `[and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]` colB } }`
+     *
+     * is shorthand for
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColGroup.`[select][org.jetbrains.kotlinx.dataframe.api.SelectColumnsSelectionDsl.select]`  {  `[all][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.all]`() `[except][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.except]`  { colA  `[and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]` colB } } }`
+     *
+     * or
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColGroup.`[allCols][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allCols]`() `[except][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.except]`  { myColGroup.colA  `[and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]` myColGroup.colB } }`
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * Also note the name change, similar to [allCols][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allCols], this makes it clearer that you're selecting
+     * columns inside the group, 'lifting' them out.
+     *
+     * ### Examples for this overload
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.api.SelectColumnsSelectionDsl.select]`  {  `[allExcept][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.allExcept]`(age, height)`` }`
+     *
+     *  `df.`[select][org.jetbrains.kotlinx.dataframe.api.SelectColumnsSelectionDsl.select]`  {  `[allExcept][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.allExcept]`(name.firstName, name.middleName)`` }`
+     *
+     * @param [others] A [ColumnsResolver] containing the columns that need to be
+     *  excluded from the current selection.
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns in [this] except the specified ones.
+     * @see ColumnsSelectionDsl.select
+     * @see ColumnsSelectionDsl.all
+     * @see ColumnsSelectionDsl.allBefore
+     * @see ColumnsSelectionDsl.allAfter
+     * @see ColumnsSelectionDsl.allUpTo
+     * @see ColumnsSelectionDsl.allFrom
+     */
+    public fun ColumnsSelectionDsl<*>.allExcept(vararg others: ColumnsResolver<*>): ColumnSet<*> =
+        asSingleColumn().allColsExceptInternal(others.toColumnSet())
+
+    /**
+     * ## (All) (Cols) Except
+     *
+     * Perform a selection of columns using the [Columns Selection DSL][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl] to
+     * exclude from the current selection.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.AllExceptColumnsSelectionDsl.Grammar]
+     *
+     * ### On [ColumnSets][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]
+     * This function can be explained the easiest with [ColumnSets][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]. Let's say we want all
+     * [Int] columns apart from `age`  and  `height`.
+     *
+     * We can do:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsOf][org.jetbrains.kotlinx.dataframe.api.colsOf]`<`[Int][Int]`>() `[except][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.except]`  (age  `[and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]` height) }`
+     *
+     * which will 'subtract' the [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] created by `age `[and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]` height` from the [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] created by [colsOf][org.jetbrains.kotlinx.dataframe.api.colsOf]`<`[Int][Int]`>()`.
+     *
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * This operation can also be used to exclude columns from [Column Groups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * For instance:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsAtAnyDepth][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsAtAnyDepth]`  { "a"  `[in][String.contains]` it.`[name][org.jetbrains.kotlinx.dataframe.DataColumn.name]`() } `[except][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.except]` userData.age }`
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     * Note that the selection of columns to exclude from [column sets][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] is always done relative to the outer
+     * scope. Use the [Extension Properties API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi.ExtensionPropertiesApi] to prevent scoping issues if possible.
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * Special case: If a column that needs to be removed appears multiple times in the [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet], it is excepted
+     * each time it is encountered (including inside [ColumnGroups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup]). You could say the receiver [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]
+     * is [simplified][org.jetbrains.kotlinx.dataframe.api.SimplifyColumnsSelectionDsl.simplify] before the operation is performed:
+     *
+     * [cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`(a, a, a.b, a.b).`[except][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.except]`(a.b)`
+     *
+     * `== `[cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`(a).`[except][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.except]`(a.b)`
+     *
+     * ### In the [ColumnsSelectionDsl][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl]
+     * Instead of having to write [all][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.all]`() `[except][org.jetbrains.kotlinx.dataframe.api.AllExceptColumnsSelectionDsl.except]` { ... }` in the DSL,
+     * you can use [allExcept][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.allExcept]` { ... }` to achieve the same result.
+     *
+     * For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[allExcept][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.allExcept]`  { userData.age  `[and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]` height } }`
+     *
+     * ### On [ColumnGroups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup]
+     * The variant of this function on [ColumnGroups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup] is a bit different as it changes the scope relative to
+     * the column group.
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * In other words:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColGroup.`[allColsExcept][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.allColsExcept]`  { colA  `[and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]` colB } }`
+     *
+     * is shorthand for
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColGroup.`[select][org.jetbrains.kotlinx.dataframe.api.SelectColumnsSelectionDsl.select]`  {  `[all][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.all]`() `[except][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.except]`  { colA  `[and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]` colB } } }`
+     *
+     * or
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColGroup.`[allCols][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allCols]`() `[except][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.except]`  { myColGroup.colA  `[and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]` myColGroup.colB } }`
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * Also note the name change, similar to [allCols][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allCols], this makes it clearer that you're selecting
+     * columns inside the group, 'lifting' them out.
+     *
+     * ### Examples for this overload
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.api.SelectColumnsSelectionDsl.select]`  {  `[allExcept][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.allExcept]`("age", "height")`` }`
+     *
+     *  `df.`[select][org.jetbrains.kotlinx.dataframe.api.SelectColumnsSelectionDsl.select]`  {  `[allExcept][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.allExcept]`("name")`` }`
+     *
+     * @param [others] Any number of [Strings][String] referring to
+     *  the columns (relative to the current scope) that need to be excluded from the current selection.
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns in [this] except the specified ones.
+     * @see ColumnsSelectionDsl.select
+     * @see ColumnsSelectionDsl.all
+     * @see ColumnsSelectionDsl.allBefore
+     * @see ColumnsSelectionDsl.allAfter
+     * @see ColumnsSelectionDsl.allUpTo
+     * @see ColumnsSelectionDsl.allFrom
+     */
+    public fun ColumnsSelectionDsl<*>.allExcept(vararg others: String): ColumnSet<*> =
+        asSingleColumn().allColsExceptInternal(others.toColumnSet())
+
+    /**
+     * ## (All) (Cols) Except
+     *
+     * Perform a selection of columns using the [Columns Selection DSL][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl] to
+     * exclude from the current selection.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.AllExceptColumnsSelectionDsl.Grammar]
+     *
+     * ### On [ColumnSets][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]
+     * This function can be explained the easiest with [ColumnSets][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]. Let's say we want all
+     * [Int] columns apart from `age`  and  `height`.
+     *
+     * We can do:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsOf][org.jetbrains.kotlinx.dataframe.api.colsOf]`<`[Int][Int]`>() `[except][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.except]`  (age  `[and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]` height) }`
+     *
+     * which will 'subtract' the [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] created by `age `[and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]` height` from the [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] created by [colsOf][org.jetbrains.kotlinx.dataframe.api.colsOf]`<`[Int][Int]`>()`.
+     *
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * This operation can also be used to exclude columns from [Column Groups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * For instance:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsAtAnyDepth][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsAtAnyDepth]`  { "a"  `[in][String.contains]` it.`[name][org.jetbrains.kotlinx.dataframe.DataColumn.name]`() } `[except][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.except]` userData.age }`
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     * Note that the selection of columns to exclude from [column sets][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] is always done relative to the outer
+     * scope. Use the [Extension Properties API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi.ExtensionPropertiesApi] to prevent scoping issues if possible.
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * Special case: If a column that needs to be removed appears multiple times in the [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet], it is excepted
+     * each time it is encountered (including inside [ColumnGroups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup]). You could say the receiver [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]
+     * is [simplified][org.jetbrains.kotlinx.dataframe.api.SimplifyColumnsSelectionDsl.simplify] before the operation is performed:
+     *
+     * [cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`(a, a, a.b, a.b).`[except][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.except]`(a.b)`
+     *
+     * `== `[cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`(a).`[except][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.except]`(a.b)`
+     *
+     * ### In the [ColumnsSelectionDsl][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl]
+     * Instead of having to write [all][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.all]`() `[except][org.jetbrains.kotlinx.dataframe.api.AllExceptColumnsSelectionDsl.except]` { ... }` in the DSL,
+     * you can use [allExcept][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.allExcept]` { ... }` to achieve the same result.
+     *
+     * For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[allExcept][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.allExcept]`  { userData.age  `[and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]` height } }`
+     *
+     * ### On [ColumnGroups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup]
+     * The variant of this function on [ColumnGroups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup] is a bit different as it changes the scope relative to
+     * the column group.
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * In other words:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColGroup.`[allColsExcept][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.allColsExcept]`  { colA  `[and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]` colB } }`
+     *
+     * is shorthand for
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColGroup.`[select][org.jetbrains.kotlinx.dataframe.api.SelectColumnsSelectionDsl.select]`  {  `[all][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.all]`() `[except][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.except]`  { colA  `[and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]` colB } } }`
+     *
+     * or
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColGroup.`[allCols][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allCols]`() `[except][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.except]`  { myColGroup.colA  `[and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]` myColGroup.colB } }`
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * Also note the name change, similar to [allCols][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allCols], this makes it clearer that you're selecting
+     * columns inside the group, 'lifting' them out.
+     *
+     * ### Examples for this overload
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.api.SelectColumnsSelectionDsl.select]`  {  `[allExcept][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.allExcept]`(Person::age, Person::height)`` }`
+     *
+     *  `df.`[select][org.jetbrains.kotlinx.dataframe.api.SelectColumnsSelectionDsl.select]`  {  `[allExcept][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.allExcept]`(Person::name)`` }`
+     *
+     * @param [others] Any number of [KProperties][KProperty] referring to
+     *  the columns (relative to the current scope) that need to be excluded from the current selection.
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns in [this] except the specified ones.
+     * @see ColumnsSelectionDsl.select
+     * @see ColumnsSelectionDsl.all
+     * @see ColumnsSelectionDsl.allBefore
+     * @see ColumnsSelectionDsl.allAfter
+     * @see ColumnsSelectionDsl.allUpTo
+     * @see ColumnsSelectionDsl.allFrom
+     */
+    public fun ColumnsSelectionDsl<*>.allExcept(vararg others: KProperty<*>): ColumnSet<*> =
+        asSingleColumn().allColsExceptInternal(others.toColumnSet())
+
+    /**
+     * ## (All) (Cols) Except
+     *
+     * Perform a selection of columns using the [Columns Selection DSL][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl] to
+     * exclude from the current selection.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.AllExceptColumnsSelectionDsl.Grammar]
+     *
+     * ### On [ColumnSets][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]
+     * This function can be explained the easiest with [ColumnSets][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]. Let's say we want all
+     * [Int] columns apart from `age`  and  `height`.
+     *
+     * We can do:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsOf][org.jetbrains.kotlinx.dataframe.api.colsOf]`<`[Int][Int]`>() `[except][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.except]`  (age  `[and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]` height) }`
+     *
+     * which will 'subtract' the [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] created by `age `[and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]` height` from the [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] created by [colsOf][org.jetbrains.kotlinx.dataframe.api.colsOf]`<`[Int][Int]`>()`.
+     *
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * This operation can also be used to exclude columns from [Column Groups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * For instance:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsAtAnyDepth][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsAtAnyDepth]`  { "a"  `[in][String.contains]` it.`[name][org.jetbrains.kotlinx.dataframe.DataColumn.name]`() } `[except][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.except]` userData.age }`
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     * Note that the selection of columns to exclude from [column sets][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] is always done relative to the outer
+     * scope. Use the [Extension Properties API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi.ExtensionPropertiesApi] to prevent scoping issues if possible.
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * Special case: If a column that needs to be removed appears multiple times in the [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet], it is excepted
+     * each time it is encountered (including inside [ColumnGroups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup]). You could say the receiver [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]
+     * is [simplified][org.jetbrains.kotlinx.dataframe.api.SimplifyColumnsSelectionDsl.simplify] before the operation is performed:
+     *
+     * [cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`(a, a, a.b, a.b).`[except][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.except]`(a.b)`
+     *
+     * `== `[cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`(a).`[except][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.except]`(a.b)`
+     *
+     * ### In the [ColumnsSelectionDsl][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl]
+     * Instead of having to write [all][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.all]`() `[except][org.jetbrains.kotlinx.dataframe.api.AllExceptColumnsSelectionDsl.except]` { ... }` in the DSL,
+     * you can use [allExcept][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.allExcept]` { ... }` to achieve the same result.
+     *
+     * For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[allExcept][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.allExcept]`  { userData.age  `[and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]` height } }`
+     *
+     * ### On [ColumnGroups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup]
+     * The variant of this function on [ColumnGroups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup] is a bit different as it changes the scope relative to
+     * the column group.
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * In other words:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColGroup.`[allColsExcept][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.allColsExcept]`  { colA  `[and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]` colB } }`
+     *
+     * is shorthand for
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColGroup.`[select][org.jetbrains.kotlinx.dataframe.api.SelectColumnsSelectionDsl.select]`  {  `[all][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.all]`() `[except][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.except]`  { colA  `[and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]` colB } } }`
+     *
+     * or
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColGroup.`[allCols][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allCols]`() `[except][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.except]`  { myColGroup.colA  `[and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]` myColGroup.colB } }`
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * Also note the name change, similar to [allCols][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allCols], this makes it clearer that you're selecting
+     * columns inside the group, 'lifting' them out.
+     *
+     * ### Examples for this overload
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.api.SelectColumnsSelectionDsl.select]`  {  `[allExcept][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.allExcept]`(pathOf("age"), "userdata"["height"])`` }`
+     *
+     *  `df.`[select][org.jetbrains.kotlinx.dataframe.api.SelectColumnsSelectionDsl.select]`  {  `[allExcept][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.allExcept]`("name"["firstName"], "name"["middleName"])`` }`
+     *
+     * @param [others] Any number of [ColumnPaths][ColumnPath] referring to
+     *  the columns (relative to the current scope) that need to be excluded from the current selection.
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns in [this] except the specified ones.
+     * @see ColumnsSelectionDsl.select
+     * @see ColumnsSelectionDsl.all
+     * @see ColumnsSelectionDsl.allBefore
+     * @see ColumnsSelectionDsl.allAfter
+     * @see ColumnsSelectionDsl.allUpTo
+     * @see ColumnsSelectionDsl.allFrom
+     */
+    public fun ColumnsSelectionDsl<*>.allExcept(vararg others: ColumnPath): ColumnSet<*> =
+        asSingleColumn().allColsExceptInternal(others.toColumnSet())
+
+    // endregion
+
+    // region SingleColumn
+
+    /**
+     * ## (All) (Cols) Except
+     *
+     * Perform a selection of columns using the [Columns Selection DSL][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl] to
+     * exclude from the current selection.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.AllExceptColumnsSelectionDsl.Grammar]
+     *
+     * ### On [ColumnSets][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]
+     * This function can be explained the easiest with [ColumnSets][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]. Let's say we want all
+     * [Int] columns apart from `age`  and  `height`.
+     *
+     * We can do:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsOf][org.jetbrains.kotlinx.dataframe.api.colsOf]`<`[Int][Int]`>() `[except][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.except]`  (age  `[and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]` height) }`
+     *
+     * which will 'subtract' the [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] created by `age `[and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]` height` from the [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] created by [colsOf][org.jetbrains.kotlinx.dataframe.api.colsOf]`<`[Int][Int]`>()`.
+     *
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * This operation can also be used to exclude columns from [Column Groups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * For instance:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsAtAnyDepth][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsAtAnyDepth]`  { "a"  `[in][String.contains]` it.`[name][org.jetbrains.kotlinx.dataframe.DataColumn.name]`() } `[except][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.except]` userData.age }`
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     * Note that the selection of columns to exclude from [column sets][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] is always done relative to the outer
+     * scope. Use the [Extension Properties API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi.ExtensionPropertiesApi] to prevent scoping issues if possible.
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * Special case: If a column that needs to be removed appears multiple times in the [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet], it is excepted
+     * each time it is encountered (including inside [ColumnGroups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup]). You could say the receiver [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]
+     * is [simplified][org.jetbrains.kotlinx.dataframe.api.SimplifyColumnsSelectionDsl.simplify] before the operation is performed:
+     *
+     * [cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`(a, a, a.b, a.b).`[except][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.except]`(a.b)`
+     *
+     * `== `[cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`(a).`[except][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.except]`(a.b)`
+     *
+     * ### In the [ColumnsSelectionDsl][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl]
+     * Instead of having to write [all][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.all]`() `[except][org.jetbrains.kotlinx.dataframe.api.AllExceptColumnsSelectionDsl.except]` { ... }` in the DSL,
+     * you can use [allExcept][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.allExcept]` { ... }` to achieve the same result.
+     *
+     * For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[allExcept][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.allExcept]`  { userData.age  `[and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]` height } }`
+     *
+     * ### On [ColumnGroups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup]
+     * The variant of this function on [ColumnGroups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup] is a bit different as it changes the scope relative to
+     * the column group.
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * In other words:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColGroup.`[allColsExcept][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.allColsExcept]`  { colA  `[and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]` colB } }`
+     *
+     * is shorthand for
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColGroup.`[select][org.jetbrains.kotlinx.dataframe.api.SelectColumnsSelectionDsl.select]`  {  `[all][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.all]`() `[except][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.except]`  { colA  `[and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]` colB } } }`
+     *
+     * or
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColGroup.`[allCols][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allCols]`() `[except][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.except]`  { myColGroup.colA  `[and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]` myColGroup.colB } }`
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * Also note the name change, similar to [allCols][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allCols], this makes it clearer that you're selecting
+     * columns inside the group, 'lifting' them out.
+     *
+     * ### Examples for this overload
+     *
+     *  `df.`[select][ColumnsSelectionDsl.select]`  {  `<code></code>[allColsExcept][.allColsExcept]<code></code>` }`
+     *
+     *  `df.`[select][ColumnsSelectionDsl.select]`  { city  `[and][ColumnsSelectionDsl.and]` `<code></code>[allColsExcept][.allColsExcept]<code></code>` }`
+     *
+     *
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns in [this] except the specified ones.
+     * @see ColumnsSelectionDsl.select
+     * @see ColumnsSelectionDsl.all
+     * @see ColumnsSelectionDsl.allBefore
+     * @see ColumnsSelectionDsl.allAfter
+     * @see ColumnsSelectionDsl.allUpTo
+     * @see ColumnsSelectionDsl.allFrom
+     */
+    private interface ColumnGroupDocs {
+
+        // receiver
+        interface ReceiverArg1
+
+        // receiver
+        interface ReceiverArg2
+
+        // type
+        interface ReceiverType
+
+        // argument
+        interface ArgumentArg1
+
+        // argument
+        interface ArgumentArg2
+
+        /**
+         */
+        interface SingleColumnReceiverArgs
+
+        /**
+         */
+        interface StringReceiverArgs
+
+        /**
+         */
+        interface KPropertyReceiverArgs
+
+        /**
+         */
+        interface ColumnPathReceiverArgs
+
+        /**
+         */
+        interface SelectorArgs
+
+        /**
+         */
+        interface StringArgs
+
+        /**
+         */
+        interface KPropertyArgs
+
+        /**
+         */
+        interface ColumnPathArgs
+    }
+
+    /**
+     * ## (All) (Cols) Except
+     *
+     * Perform a selection of columns using the [Columns Selection DSL][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl] to
+     * exclude from the current selection.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.AllExceptColumnsSelectionDsl.Grammar]
+     *
+     * ### On [ColumnSets][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]
+     * This function can be explained the easiest with [ColumnSets][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]. Let's say we want all
+     * [Int] columns apart from `age`  and  `height`.
+     *
+     * We can do:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsOf][org.jetbrains.kotlinx.dataframe.api.colsOf]`<`[Int][Int]`>() `[except][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.except]`  (age  `[and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]` height) }`
+     *
+     * which will 'subtract' the [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] created by `age `[and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]` height` from the [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] created by [colsOf][org.jetbrains.kotlinx.dataframe.api.colsOf]`<`[Int][Int]`>()`.
+     *
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * This operation can also be used to exclude columns from [Column Groups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * For instance:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsAtAnyDepth][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsAtAnyDepth]`  { "a"  `[in][String.contains]` it.`[name][org.jetbrains.kotlinx.dataframe.DataColumn.name]`() } `[except][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.except]` userData.age }`
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     * Note that the selection of columns to exclude from [column sets][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] is always done relative to the outer
+     * scope. Use the [Extension Properties API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi.ExtensionPropertiesApi] to prevent scoping issues if possible.
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * Special case: If a column that needs to be removed appears multiple times in the [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet], it is excepted
+     * each time it is encountered (including inside [ColumnGroups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup]). You could say the receiver [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]
+     * is [simplified][org.jetbrains.kotlinx.dataframe.api.SimplifyColumnsSelectionDsl.simplify] before the operation is performed:
+     *
+     * [cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`(a, a, a.b, a.b).`[except][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.except]`(a.b)`
+     *
+     * `== `[cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`(a).`[except][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.except]`(a.b)`
+     *
+     * ### In the [ColumnsSelectionDsl][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl]
+     * Instead of having to write [all][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.all]`() `[except][org.jetbrains.kotlinx.dataframe.api.AllExceptColumnsSelectionDsl.except]` { ... }` in the DSL,
+     * you can use [allExcept][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.allExcept]` { ... }` to achieve the same result.
+     *
+     * For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[allExcept][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.allExcept]`  { userData.age  `[and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]` height } }`
+     *
+     * ### On [ColumnGroups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup]
+     * The variant of this function on [ColumnGroups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup] is a bit different as it changes the scope relative to
+     * the column group.
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * In other words:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColGroup.`[allColsExcept][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.allColsExcept]`  { colA  `[and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]` colB } }`
+     *
+     * is shorthand for
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColGroup.`[select][org.jetbrains.kotlinx.dataframe.api.SelectColumnsSelectionDsl.select]`  {  `[all][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.all]`() `[except][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.except]`  { colA  `[and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]` colB } } }`
+     *
+     * or
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColGroup.`[allCols][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allCols]`() `[except][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.except]`  { myColGroup.colA  `[and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]` myColGroup.colB } }`
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * Also note the name change, similar to [allCols][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allCols], this makes it clearer that you're selecting
+     * columns inside the group, 'lifting' them out.
+     *
+     * ### Examples for this overload
+     *
+     *  `df.`[select][org.jetbrains.kotlinx.dataframe.api.SelectColumnsSelectionDsl.select]`  {  `<code>`userData.`</code>[allColsExcept][SingleColumn.allColsExcept]<code>`  { "age"  `[and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]` height }`</code>` }`
+     *
+     *  `df.`[select][org.jetbrains.kotlinx.dataframe.api.SelectColumnsSelectionDsl.select]`  { city  `[and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]` `<code>`name.`</code>[allColsExcept][SingleColumn.allColsExcept]<code>` { firstName }`</code>` }`
+     *
+     * @param [selector] A lambda in which you specify the columns that need to be
+     *  excluded from the current selection in [this] column group. The other columns will be included in the selection
+     *  by default. The scope of the selector is relative to the column group.
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns in [this] except the specified ones.
+     * @see ColumnsSelectionDsl.select
+     * @see ColumnsSelectionDsl.all
+     * @see ColumnsSelectionDsl.allBefore
+     * @see ColumnsSelectionDsl.allAfter
+     * @see ColumnsSelectionDsl.allUpTo
+     * @see ColumnsSelectionDsl.allFrom
+     */
+    public fun <C> SingleColumn<DataRow<C>>.allColsExcept(selector: ColumnsSelector<C, *>): ColumnSet<*> =
+        allColsExceptInternal(selector.toColumns())
+
+    @Deprecated(
+        message = ALL_COLS_EXCEPT,
+        replaceWith = ReplaceWith(ALL_COLS_REPLACE),
+        level = DeprecationLevel.ERROR,
+    ) // present solely to redirect users to the right function
+    public fun SingleColumn<DataRow<*>>.allColsExcept(other: ColumnsResolver<*>): ColumnSet<*> =
+        allColsExcept { other }
+
+    @Deprecated(
+        message = ALL_COLS_EXCEPT,
+        replaceWith = ReplaceWith(ALL_COLS_REPLACE_VARARG),
+        level = DeprecationLevel.ERROR,
+    ) // present solely to redirect users to the right function
+    public fun SingleColumn<DataRow<*>>.allColsExcept(vararg others: ColumnsResolver<*>): ColumnSet<*> =
+        allColsExcept { others.toColumnSet() }
+
+    /**
+     * ## (All) (Cols) Except
+     *
+     * Perform a selection of columns using the [Columns Selection DSL][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl] to
+     * exclude from the current selection.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.AllExceptColumnsSelectionDsl.Grammar]
+     *
+     * ### On [ColumnSets][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]
+     * This function can be explained the easiest with [ColumnSets][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]. Let's say we want all
+     * [Int] columns apart from `age`  and  `height`.
+     *
+     * We can do:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsOf][org.jetbrains.kotlinx.dataframe.api.colsOf]`<`[Int][Int]`>() `[except][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.except]`  (age  `[and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]` height) }`
+     *
+     * which will 'subtract' the [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] created by `age `[and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]` height` from the [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] created by [colsOf][org.jetbrains.kotlinx.dataframe.api.colsOf]`<`[Int][Int]`>()`.
+     *
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * This operation can also be used to exclude columns from [Column Groups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * For instance:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsAtAnyDepth][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsAtAnyDepth]`  { "a"  `[in][String.contains]` it.`[name][org.jetbrains.kotlinx.dataframe.DataColumn.name]`() } `[except][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.except]` userData.age }`
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     * Note that the selection of columns to exclude from [column sets][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] is always done relative to the outer
+     * scope. Use the [Extension Properties API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi.ExtensionPropertiesApi] to prevent scoping issues if possible.
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * Special case: If a column that needs to be removed appears multiple times in the [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet], it is excepted
+     * each time it is encountered (including inside [ColumnGroups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup]). You could say the receiver [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]
+     * is [simplified][org.jetbrains.kotlinx.dataframe.api.SimplifyColumnsSelectionDsl.simplify] before the operation is performed:
+     *
+     * [cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`(a, a, a.b, a.b).`[except][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.except]`(a.b)`
+     *
+     * `== `[cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`(a).`[except][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.except]`(a.b)`
+     *
+     * ### In the [ColumnsSelectionDsl][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl]
+     * Instead of having to write [all][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.all]`() `[except][org.jetbrains.kotlinx.dataframe.api.AllExceptColumnsSelectionDsl.except]` { ... }` in the DSL,
+     * you can use [allExcept][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.allExcept]` { ... }` to achieve the same result.
+     *
+     * For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[allExcept][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.allExcept]`  { userData.age  `[and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]` height } }`
+     *
+     * ### On [ColumnGroups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup]
+     * The variant of this function on [ColumnGroups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup] is a bit different as it changes the scope relative to
+     * the column group.
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * In other words:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColGroup.`[allColsExcept][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.allColsExcept]`  { colA  `[and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]` colB } }`
+     *
+     * is shorthand for
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColGroup.`[select][org.jetbrains.kotlinx.dataframe.api.SelectColumnsSelectionDsl.select]`  {  `[all][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.all]`() `[except][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.except]`  { colA  `[and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]` colB } } }`
+     *
+     * or
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColGroup.`[allCols][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allCols]`() `[except][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.except]`  { myColGroup.colA  `[and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]` myColGroup.colB } }`
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * Also note the name change, similar to [allCols][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allCols], this makes it clearer that you're selecting
+     * columns inside the group, 'lifting' them out.
+     *
+     * ### Examples for this overload
+     *
+     *  `df.`[select][org.jetbrains.kotlinx.dataframe.api.SelectColumnsSelectionDsl.select]`  {  `<code>`userData.`</code>[allColsExcept][SingleColumn.allColsExcept]<code>`("age", "height")`</code>` }`
+     *
+     *  `df.`[select][org.jetbrains.kotlinx.dataframe.api.SelectColumnsSelectionDsl.select]`  { city  `[and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]` `<code>`name.`</code>[allColsExcept][SingleColumn.allColsExcept]<code>`("firstName", "middleName")`</code>` }`
+     *
+     * @param [others] Any number of [Strings][String] referring to
+     *  the columns (relative to the column group) that need to be excluded from the current selection in [this]
+     *  column group. The other columns will be included in the selection by default.
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns in [this] except the specified ones.
+     * @see ColumnsSelectionDsl.select
+     * @see ColumnsSelectionDsl.all
+     * @see ColumnsSelectionDsl.allBefore
+     * @see ColumnsSelectionDsl.allAfter
+     * @see ColumnsSelectionDsl.allUpTo
+     * @see ColumnsSelectionDsl.allFrom
+     */
+    public fun SingleColumn<DataRow<*>>.allColsExcept(vararg others: String): ColumnSet<*> =
+        allColsExceptInternal(others.toColumnSet())
+
+    /**
+     * ## (All) (Cols) Except
+     *
+     * Perform a selection of columns using the [Columns Selection DSL][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl] to
+     * exclude from the current selection.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.AllExceptColumnsSelectionDsl.Grammar]
+     *
+     * ### On [ColumnSets][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]
+     * This function can be explained the easiest with [ColumnSets][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]. Let's say we want all
+     * [Int] columns apart from `age`  and  `height`.
+     *
+     * We can do:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsOf][org.jetbrains.kotlinx.dataframe.api.colsOf]`<`[Int][Int]`>() `[except][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.except]`  (age  `[and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]` height) }`
+     *
+     * which will 'subtract' the [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] created by `age `[and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]` height` from the [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] created by [colsOf][org.jetbrains.kotlinx.dataframe.api.colsOf]`<`[Int][Int]`>()`.
+     *
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * This operation can also be used to exclude columns from [Column Groups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * For instance:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsAtAnyDepth][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsAtAnyDepth]`  { "a"  `[in][String.contains]` it.`[name][org.jetbrains.kotlinx.dataframe.DataColumn.name]`() } `[except][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.except]` userData.age }`
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     * Note that the selection of columns to exclude from [column sets][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] is always done relative to the outer
+     * scope. Use the [Extension Properties API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi.ExtensionPropertiesApi] to prevent scoping issues if possible.
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * Special case: If a column that needs to be removed appears multiple times in the [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet], it is excepted
+     * each time it is encountered (including inside [ColumnGroups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup]). You could say the receiver [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]
+     * is [simplified][org.jetbrains.kotlinx.dataframe.api.SimplifyColumnsSelectionDsl.simplify] before the operation is performed:
+     *
+     * [cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`(a, a, a.b, a.b).`[except][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.except]`(a.b)`
+     *
+     * `== `[cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`(a).`[except][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.except]`(a.b)`
+     *
+     * ### In the [ColumnsSelectionDsl][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl]
+     * Instead of having to write [all][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.all]`() `[except][org.jetbrains.kotlinx.dataframe.api.AllExceptColumnsSelectionDsl.except]` { ... }` in the DSL,
+     * you can use [allExcept][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.allExcept]` { ... }` to achieve the same result.
+     *
+     * For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[allExcept][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.allExcept]`  { userData.age  `[and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]` height } }`
+     *
+     * ### On [ColumnGroups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup]
+     * The variant of this function on [ColumnGroups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup] is a bit different as it changes the scope relative to
+     * the column group.
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * In other words:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColGroup.`[allColsExcept][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.allColsExcept]`  { colA  `[and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]` colB } }`
+     *
+     * is shorthand for
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColGroup.`[select][org.jetbrains.kotlinx.dataframe.api.SelectColumnsSelectionDsl.select]`  {  `[all][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.all]`() `[except][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.except]`  { colA  `[and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]` colB } } }`
+     *
+     * or
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColGroup.`[allCols][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allCols]`() `[except][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.except]`  { myColGroup.colA  `[and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]` myColGroup.colB } }`
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * Also note the name change, similar to [allCols][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allCols], this makes it clearer that you're selecting
+     * columns inside the group, 'lifting' them out.
+     *
+     * ### Examples for this overload
+     *
+     *  `df.`[select][org.jetbrains.kotlinx.dataframe.api.SelectColumnsSelectionDsl.select]`  {  `<code>`userData.`</code>[allColsExcept][SingleColumn.allColsExcept]<code>`(Person::age, Person::height)`</code>` }`
+     *
+     *  `df.`[select][org.jetbrains.kotlinx.dataframe.api.SelectColumnsSelectionDsl.select]`  { city  `[and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]` `<code>`name.`</code>[allColsExcept][SingleColumn.allColsExcept]<code>`(Person::firstName, Person::middleName)`</code>` }`
+     *
+     * @param [others] Any number of [KProperties][KProperty] referring to
+     *  the columns (relative to the column group) that need to be excluded from the current selection in [this]
+     *  column group. The other columns will be included in the selection by default.
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns in [this] except the specified ones.
+     * @see ColumnsSelectionDsl.select
+     * @see ColumnsSelectionDsl.all
+     * @see ColumnsSelectionDsl.allBefore
+     * @see ColumnsSelectionDsl.allAfter
+     * @see ColumnsSelectionDsl.allUpTo
+     * @see ColumnsSelectionDsl.allFrom
+     */
+    public fun SingleColumn<DataRow<*>>.allColsExcept(vararg others: KProperty<*>): ColumnSet<*> =
+        allColsExceptInternal(others.toColumnSet())
+
+    /**
+     * ## (All) (Cols) Except
+     *
+     * Perform a selection of columns using the [Columns Selection DSL][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl] to
+     * exclude from the current selection.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.AllExceptColumnsSelectionDsl.Grammar]
+     *
+     * ### On [ColumnSets][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]
+     * This function can be explained the easiest with [ColumnSets][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]. Let's say we want all
+     * [Int] columns apart from `age`  and  `height`.
+     *
+     * We can do:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsOf][org.jetbrains.kotlinx.dataframe.api.colsOf]`<`[Int][Int]`>() `[except][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.except]`  (age  `[and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]` height) }`
+     *
+     * which will 'subtract' the [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] created by `age `[and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]` height` from the [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] created by [colsOf][org.jetbrains.kotlinx.dataframe.api.colsOf]`<`[Int][Int]`>()`.
+     *
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * This operation can also be used to exclude columns from [Column Groups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * For instance:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsAtAnyDepth][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsAtAnyDepth]`  { "a"  `[in][String.contains]` it.`[name][org.jetbrains.kotlinx.dataframe.DataColumn.name]`() } `[except][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.except]` userData.age }`
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     * Note that the selection of columns to exclude from [column sets][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] is always done relative to the outer
+     * scope. Use the [Extension Properties API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi.ExtensionPropertiesApi] to prevent scoping issues if possible.
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * Special case: If a column that needs to be removed appears multiple times in the [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet], it is excepted
+     * each time it is encountered (including inside [ColumnGroups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup]). You could say the receiver [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]
+     * is [simplified][org.jetbrains.kotlinx.dataframe.api.SimplifyColumnsSelectionDsl.simplify] before the operation is performed:
+     *
+     * [cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`(a, a, a.b, a.b).`[except][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.except]`(a.b)`
+     *
+     * `== `[cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`(a).`[except][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.except]`(a.b)`
+     *
+     * ### In the [ColumnsSelectionDsl][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl]
+     * Instead of having to write [all][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.all]`() `[except][org.jetbrains.kotlinx.dataframe.api.AllExceptColumnsSelectionDsl.except]` { ... }` in the DSL,
+     * you can use [allExcept][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.allExcept]` { ... }` to achieve the same result.
+     *
+     * For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[allExcept][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.allExcept]`  { userData.age  `[and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]` height } }`
+     *
+     * ### On [ColumnGroups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup]
+     * The variant of this function on [ColumnGroups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup] is a bit different as it changes the scope relative to
+     * the column group.
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * In other words:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColGroup.`[allColsExcept][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.allColsExcept]`  { colA  `[and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]` colB } }`
+     *
+     * is shorthand for
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColGroup.`[select][org.jetbrains.kotlinx.dataframe.api.SelectColumnsSelectionDsl.select]`  {  `[all][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.all]`() `[except][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.except]`  { colA  `[and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]` colB } } }`
+     *
+     * or
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColGroup.`[allCols][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allCols]`() `[except][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.except]`  { myColGroup.colA  `[and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]` myColGroup.colB } }`
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * Also note the name change, similar to [allCols][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allCols], this makes it clearer that you're selecting
+     * columns inside the group, 'lifting' them out.
+     *
+     * ### Examples for this overload
+     *
+     *  `df.`[select][org.jetbrains.kotlinx.dataframe.api.SelectColumnsSelectionDsl.select]`  {  `<code>`userData.`</code>[allColsExcept][SingleColumn.allColsExcept]<code>`(pathOf("age"), "extraData"["item1"])`</code>` }`
+     *
+     *  `df.`[select][org.jetbrains.kotlinx.dataframe.api.SelectColumnsSelectionDsl.select]`  { city  `[and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]` `<code>`name.`</code>[allColsExcept][SingleColumn.allColsExcept]<code>`(pathOf("firstName"), "middleNames"["first"])`</code>` }`
+     *
+     * @param [others] Any number of [ColumnPaths][org.jetbrains.kotlinx.dataframe.columns.ColumnPath] referring to
+     *  the columns (relative to the column group) that need to be excluded from the current selection in [this]
+     *  column group. The other columns will be included in the selection by default.
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns in [this] except the specified ones.
+     * @see ColumnsSelectionDsl.select
+     * @see ColumnsSelectionDsl.all
+     * @see ColumnsSelectionDsl.allBefore
+     * @see ColumnsSelectionDsl.allAfter
+     * @see ColumnsSelectionDsl.allUpTo
+     * @see ColumnsSelectionDsl.allFrom
+     */
+    public fun SingleColumn<DataRow<*>>.allColsExcept(vararg other: ColumnPath): ColumnSet<*> =
+        allColsExceptInternal(other.toColumnSet())
+
+    // endregion
+
+    // region String
+
+    /**
+     * ## (All) (Cols) Except
+     *
+     * Perform a selection of columns using the [Columns Selection DSL][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl] to
+     * exclude from the current selection.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.AllExceptColumnsSelectionDsl.Grammar]
+     *
+     * ### On [ColumnSets][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]
+     * This function can be explained the easiest with [ColumnSets][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]. Let's say we want all
+     * [Int] columns apart from `age`  and  `height`.
+     *
+     * We can do:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsOf][org.jetbrains.kotlinx.dataframe.api.colsOf]`<`[Int][Int]`>() `[except][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.except]`  (age  `[and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]` height) }`
+     *
+     * which will 'subtract' the [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] created by `age `[and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]` height` from the [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] created by [colsOf][org.jetbrains.kotlinx.dataframe.api.colsOf]`<`[Int][Int]`>()`.
+     *
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * This operation can also be used to exclude columns from [Column Groups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * For instance:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsAtAnyDepth][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsAtAnyDepth]`  { "a"  `[in][String.contains]` it.`[name][org.jetbrains.kotlinx.dataframe.DataColumn.name]`() } `[except][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.except]` userData.age }`
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     * Note that the selection of columns to exclude from [column sets][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] is always done relative to the outer
+     * scope. Use the [Extension Properties API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi.ExtensionPropertiesApi] to prevent scoping issues if possible.
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * Special case: If a column that needs to be removed appears multiple times in the [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet], it is excepted
+     * each time it is encountered (including inside [ColumnGroups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup]). You could say the receiver [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]
+     * is [simplified][org.jetbrains.kotlinx.dataframe.api.SimplifyColumnsSelectionDsl.simplify] before the operation is performed:
+     *
+     * [cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`(a, a, a.b, a.b).`[except][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.except]`(a.b)`
+     *
+     * `== `[cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`(a).`[except][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.except]`(a.b)`
+     *
+     * ### In the [ColumnsSelectionDsl][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl]
+     * Instead of having to write [all][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.all]`() `[except][org.jetbrains.kotlinx.dataframe.api.AllExceptColumnsSelectionDsl.except]` { ... }` in the DSL,
+     * you can use [allExcept][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.allExcept]` { ... }` to achieve the same result.
+     *
+     * For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[allExcept][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.allExcept]`  { userData.age  `[and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]` height } }`
+     *
+     * ### On [ColumnGroups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup]
+     * The variant of this function on [ColumnGroups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup] is a bit different as it changes the scope relative to
+     * the column group.
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * In other words:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColGroup.`[allColsExcept][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.allColsExcept]`  { colA  `[and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]` colB } }`
+     *
+     * is shorthand for
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColGroup.`[select][org.jetbrains.kotlinx.dataframe.api.SelectColumnsSelectionDsl.select]`  {  `[all][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.all]`() `[except][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.except]`  { colA  `[and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]` colB } } }`
+     *
+     * or
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColGroup.`[allCols][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allCols]`() `[except][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.except]`  { myColGroup.colA  `[and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]` myColGroup.colB } }`
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * Also note the name change, similar to [allCols][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allCols], this makes it clearer that you're selecting
+     * columns inside the group, 'lifting' them out.
+     *
+     * ### Examples for this overload
+     *
+     *  `df.`[select][org.jetbrains.kotlinx.dataframe.api.SelectColumnsSelectionDsl.select]`  {  `<code>`"userData".`</code>[allColsExcept][String.allColsExcept]<code>`  { "age"  `[and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]` height }`</code>` }`
+     *
+     *  `df.`[select][org.jetbrains.kotlinx.dataframe.api.SelectColumnsSelectionDsl.select]`  { city  `[and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]` `<code>`"name".`</code>[allColsExcept][String.allColsExcept]<code>` { firstName }`</code>` }`
+     *
+     * @param [selector] A lambda in which you specify the columns that need to be
+     *  excluded from the current selection in [this] column group. The other columns will be included in the selection
+     *  by default. The scope of the selector is relative to the column group.
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns in [this] except the specified ones.
+     * @see ColumnsSelectionDsl.select
+     * @see ColumnsSelectionDsl.all
+     * @see ColumnsSelectionDsl.allBefore
+     * @see ColumnsSelectionDsl.allAfter
+     * @see ColumnsSelectionDsl.allUpTo
+     * @see ColumnsSelectionDsl.allFrom
+     */
+    public fun String.allColsExcept(selector: ColumnsSelector<*, *>): ColumnSet<*> =
+        columnGroup(this).allColsExcept(selector)
+
+    @Deprecated(
+        message = ALL_COLS_EXCEPT,
+        replaceWith = ReplaceWith(ALL_COLS_REPLACE),
+        level = DeprecationLevel.ERROR,
+    ) // present solely to redirect users to the right function
+    public fun String.allColsExcept(other: ColumnsResolver<*>): ColumnSet<*> =
+        allColsExcept { other }
+
+    @Deprecated(
+        message = ALL_COLS_EXCEPT,
+        replaceWith = ReplaceWith(ALL_COLS_REPLACE_VARARG),
+        level = DeprecationLevel.ERROR,
+    ) // present solely to redirect users to the right function
+    public fun String.allColsExcept(vararg others: ColumnsResolver<*>): ColumnSet<*> =
+        allColsExcept { others.toColumnSet() }
+
+    /**
+     * ## (All) (Cols) Except
+     *
+     * Perform a selection of columns using the [Columns Selection DSL][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl] to
+     * exclude from the current selection.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.AllExceptColumnsSelectionDsl.Grammar]
+     *
+     * ### On [ColumnSets][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]
+     * This function can be explained the easiest with [ColumnSets][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]. Let's say we want all
+     * [Int] columns apart from `age`  and  `height`.
+     *
+     * We can do:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsOf][org.jetbrains.kotlinx.dataframe.api.colsOf]`<`[Int][Int]`>() `[except][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.except]`  (age  `[and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]` height) }`
+     *
+     * which will 'subtract' the [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] created by `age `[and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]` height` from the [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] created by [colsOf][org.jetbrains.kotlinx.dataframe.api.colsOf]`<`[Int][Int]`>()`.
+     *
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * This operation can also be used to exclude columns from [Column Groups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * For instance:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsAtAnyDepth][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsAtAnyDepth]`  { "a"  `[in][String.contains]` it.`[name][org.jetbrains.kotlinx.dataframe.DataColumn.name]`() } `[except][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.except]` userData.age }`
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     * Note that the selection of columns to exclude from [column sets][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] is always done relative to the outer
+     * scope. Use the [Extension Properties API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi.ExtensionPropertiesApi] to prevent scoping issues if possible.
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * Special case: If a column that needs to be removed appears multiple times in the [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet], it is excepted
+     * each time it is encountered (including inside [ColumnGroups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup]). You could say the receiver [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]
+     * is [simplified][org.jetbrains.kotlinx.dataframe.api.SimplifyColumnsSelectionDsl.simplify] before the operation is performed:
+     *
+     * [cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`(a, a, a.b, a.b).`[except][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.except]`(a.b)`
+     *
+     * `== `[cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`(a).`[except][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.except]`(a.b)`
+     *
+     * ### In the [ColumnsSelectionDsl][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl]
+     * Instead of having to write [all][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.all]`() `[except][org.jetbrains.kotlinx.dataframe.api.AllExceptColumnsSelectionDsl.except]` { ... }` in the DSL,
+     * you can use [allExcept][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.allExcept]` { ... }` to achieve the same result.
+     *
+     * For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[allExcept][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.allExcept]`  { userData.age  `[and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]` height } }`
+     *
+     * ### On [ColumnGroups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup]
+     * The variant of this function on [ColumnGroups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup] is a bit different as it changes the scope relative to
+     * the column group.
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * In other words:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColGroup.`[allColsExcept][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.allColsExcept]`  { colA  `[and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]` colB } }`
+     *
+     * is shorthand for
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColGroup.`[select][org.jetbrains.kotlinx.dataframe.api.SelectColumnsSelectionDsl.select]`  {  `[all][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.all]`() `[except][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.except]`  { colA  `[and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]` colB } } }`
+     *
+     * or
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColGroup.`[allCols][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allCols]`() `[except][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.except]`  { myColGroup.colA  `[and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]` myColGroup.colB } }`
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * Also note the name change, similar to [allCols][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allCols], this makes it clearer that you're selecting
+     * columns inside the group, 'lifting' them out.
+     *
+     * ### Examples for this overload
+     *
+     *  `df.`[select][org.jetbrains.kotlinx.dataframe.api.SelectColumnsSelectionDsl.select]`  {  `<code>`"userData".`</code>[allColsExcept][String.allColsExcept]<code>`("age", "height")`</code>` }`
+     *
+     *  `df.`[select][org.jetbrains.kotlinx.dataframe.api.SelectColumnsSelectionDsl.select]`  { city  `[and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]` `<code>`"name".`</code>[allColsExcept][String.allColsExcept]<code>`("firstName", "middleName")`</code>` }`
+     *
+     * @param [others] Any number of [Strings][String] referring to
+     *  the columns (relative to the column group) that need to be excluded from the current selection in [this]
+     *  column group. The other columns will be included in the selection by default.
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns in [this] except the specified ones.
+     * @see ColumnsSelectionDsl.select
+     * @see ColumnsSelectionDsl.all
+     * @see ColumnsSelectionDsl.allBefore
+     * @see ColumnsSelectionDsl.allAfter
+     * @see ColumnsSelectionDsl.allUpTo
+     * @see ColumnsSelectionDsl.allFrom
+     */
+    public fun String.allColsExcept(vararg others: String): ColumnSet<*> =
+        columnGroup(this).allColsExceptInternal(others.toColumnSet())
+
+    /**
+     * ## (All) (Cols) Except
+     *
+     * Perform a selection of columns using the [Columns Selection DSL][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl] to
+     * exclude from the current selection.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.AllExceptColumnsSelectionDsl.Grammar]
+     *
+     * ### On [ColumnSets][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]
+     * This function can be explained the easiest with [ColumnSets][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]. Let's say we want all
+     * [Int] columns apart from `age`  and  `height`.
+     *
+     * We can do:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsOf][org.jetbrains.kotlinx.dataframe.api.colsOf]`<`[Int][Int]`>() `[except][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.except]`  (age  `[and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]` height) }`
+     *
+     * which will 'subtract' the [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] created by `age `[and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]` height` from the [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] created by [colsOf][org.jetbrains.kotlinx.dataframe.api.colsOf]`<`[Int][Int]`>()`.
+     *
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * This operation can also be used to exclude columns from [Column Groups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * For instance:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsAtAnyDepth][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsAtAnyDepth]`  { "a"  `[in][String.contains]` it.`[name][org.jetbrains.kotlinx.dataframe.DataColumn.name]`() } `[except][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.except]` userData.age }`
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     * Note that the selection of columns to exclude from [column sets][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] is always done relative to the outer
+     * scope. Use the [Extension Properties API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi.ExtensionPropertiesApi] to prevent scoping issues if possible.
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * Special case: If a column that needs to be removed appears multiple times in the [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet], it is excepted
+     * each time it is encountered (including inside [ColumnGroups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup]). You could say the receiver [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]
+     * is [simplified][org.jetbrains.kotlinx.dataframe.api.SimplifyColumnsSelectionDsl.simplify] before the operation is performed:
+     *
+     * [cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`(a, a, a.b, a.b).`[except][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.except]`(a.b)`
+     *
+     * `== `[cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`(a).`[except][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.except]`(a.b)`
+     *
+     * ### In the [ColumnsSelectionDsl][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl]
+     * Instead of having to write [all][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.all]`() `[except][org.jetbrains.kotlinx.dataframe.api.AllExceptColumnsSelectionDsl.except]` { ... }` in the DSL,
+     * you can use [allExcept][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.allExcept]` { ... }` to achieve the same result.
+     *
+     * For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[allExcept][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.allExcept]`  { userData.age  `[and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]` height } }`
+     *
+     * ### On [ColumnGroups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup]
+     * The variant of this function on [ColumnGroups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup] is a bit different as it changes the scope relative to
+     * the column group.
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * In other words:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColGroup.`[allColsExcept][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.allColsExcept]`  { colA  `[and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]` colB } }`
+     *
+     * is shorthand for
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColGroup.`[select][org.jetbrains.kotlinx.dataframe.api.SelectColumnsSelectionDsl.select]`  {  `[all][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.all]`() `[except][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.except]`  { colA  `[and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]` colB } } }`
+     *
+     * or
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColGroup.`[allCols][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allCols]`() `[except][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.except]`  { myColGroup.colA  `[and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]` myColGroup.colB } }`
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * Also note the name change, similar to [allCols][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allCols], this makes it clearer that you're selecting
+     * columns inside the group, 'lifting' them out.
+     *
+     * ### Examples for this overload
+     *
+     *  `df.`[select][org.jetbrains.kotlinx.dataframe.api.SelectColumnsSelectionDsl.select]`  {  `<code>`"userData".`</code>[allColsExcept][String.allColsExcept]<code>`(Person::age, Person::height)`</code>` }`
+     *
+     *  `df.`[select][org.jetbrains.kotlinx.dataframe.api.SelectColumnsSelectionDsl.select]`  { city  `[and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]` `<code>`"name".`</code>[allColsExcept][String.allColsExcept]<code>`(Person::firstName, Person::middleName)`</code>` }`
+     *
+     * @param [others] Any number of [KProperties][KProperty] referring to
+     *  the columns (relative to the column group) that need to be excluded from the current selection in [this]
+     *  column group. The other columns will be included in the selection by default.
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns in [this] except the specified ones.
+     * @see ColumnsSelectionDsl.select
+     * @see ColumnsSelectionDsl.all
+     * @see ColumnsSelectionDsl.allBefore
+     * @see ColumnsSelectionDsl.allAfter
+     * @see ColumnsSelectionDsl.allUpTo
+     * @see ColumnsSelectionDsl.allFrom
+     */
+    public fun String.allColsExcept(vararg others: KProperty<*>): ColumnSet<*> =
+        columnGroup(this).allColsExceptInternal(others.toColumnSet())
+
+    /**
+     * ## (All) (Cols) Except
+     *
+     * Perform a selection of columns using the [Columns Selection DSL][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl] to
+     * exclude from the current selection.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.AllExceptColumnsSelectionDsl.Grammar]
+     *
+     * ### On [ColumnSets][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]
+     * This function can be explained the easiest with [ColumnSets][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]. Let's say we want all
+     * [Int] columns apart from `age`  and  `height`.
+     *
+     * We can do:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsOf][org.jetbrains.kotlinx.dataframe.api.colsOf]`<`[Int][Int]`>() `[except][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.except]`  (age  `[and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]` height) }`
+     *
+     * which will 'subtract' the [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] created by `age `[and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]` height` from the [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] created by [colsOf][org.jetbrains.kotlinx.dataframe.api.colsOf]`<`[Int][Int]`>()`.
+     *
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * This operation can also be used to exclude columns from [Column Groups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * For instance:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsAtAnyDepth][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsAtAnyDepth]`  { "a"  `[in][String.contains]` it.`[name][org.jetbrains.kotlinx.dataframe.DataColumn.name]`() } `[except][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.except]` userData.age }`
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     * Note that the selection of columns to exclude from [column sets][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] is always done relative to the outer
+     * scope. Use the [Extension Properties API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi.ExtensionPropertiesApi] to prevent scoping issues if possible.
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * Special case: If a column that needs to be removed appears multiple times in the [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet], it is excepted
+     * each time it is encountered (including inside [ColumnGroups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup]). You could say the receiver [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]
+     * is [simplified][org.jetbrains.kotlinx.dataframe.api.SimplifyColumnsSelectionDsl.simplify] before the operation is performed:
+     *
+     * [cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`(a, a, a.b, a.b).`[except][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.except]`(a.b)`
+     *
+     * `== `[cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`(a).`[except][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.except]`(a.b)`
+     *
+     * ### In the [ColumnsSelectionDsl][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl]
+     * Instead of having to write [all][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.all]`() `[except][org.jetbrains.kotlinx.dataframe.api.AllExceptColumnsSelectionDsl.except]` { ... }` in the DSL,
+     * you can use [allExcept][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.allExcept]` { ... }` to achieve the same result.
+     *
+     * For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[allExcept][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.allExcept]`  { userData.age  `[and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]` height } }`
+     *
+     * ### On [ColumnGroups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup]
+     * The variant of this function on [ColumnGroups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup] is a bit different as it changes the scope relative to
+     * the column group.
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * In other words:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColGroup.`[allColsExcept][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.allColsExcept]`  { colA  `[and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]` colB } }`
+     *
+     * is shorthand for
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColGroup.`[select][org.jetbrains.kotlinx.dataframe.api.SelectColumnsSelectionDsl.select]`  {  `[all][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.all]`() `[except][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.except]`  { colA  `[and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]` colB } } }`
+     *
+     * or
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColGroup.`[allCols][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allCols]`() `[except][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.except]`  { myColGroup.colA  `[and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]` myColGroup.colB } }`
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * Also note the name change, similar to [allCols][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allCols], this makes it clearer that you're selecting
+     * columns inside the group, 'lifting' them out.
+     *
+     * ### Examples for this overload
+     *
+     *  `df.`[select][org.jetbrains.kotlinx.dataframe.api.SelectColumnsSelectionDsl.select]`  {  `<code>`"userData".`</code>[allColsExcept][String.allColsExcept]<code>`(pathOf("age"), "extraData"["item1"])`</code>` }`
+     *
+     *  `df.`[select][org.jetbrains.kotlinx.dataframe.api.SelectColumnsSelectionDsl.select]`  { city  `[and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]` `<code>`"name".`</code>[allColsExcept][String.allColsExcept]<code>`(pathOf("firstName"), "middleNames"["first"])`</code>` }`
+     *
+     * @param [others] Any number of [ColumnPaths][org.jetbrains.kotlinx.dataframe.columns.ColumnPath] referring to
+     *  the columns (relative to the column group) that need to be excluded from the current selection in [this]
+     *  column group. The other columns will be included in the selection by default.
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns in [this] except the specified ones.
+     * @see ColumnsSelectionDsl.select
+     * @see ColumnsSelectionDsl.all
+     * @see ColumnsSelectionDsl.allBefore
+     * @see ColumnsSelectionDsl.allAfter
+     * @see ColumnsSelectionDsl.allUpTo
+     * @see ColumnsSelectionDsl.allFrom
+     */
+    public fun String.allColsExcept(vararg others: ColumnPath): ColumnSet<*> =
+        columnGroup(this).allColsExceptInternal(others.toColumnSet())
+
+    // endregion
+
+    // region KProperty
+
+    /**
+     * ## (All) (Cols) Except
+     *
+     * Perform a selection of columns using the [Columns Selection DSL][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl] to
+     * exclude from the current selection.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.AllExceptColumnsSelectionDsl.Grammar]
+     *
+     * ### On [ColumnSets][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]
+     * This function can be explained the easiest with [ColumnSets][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]. Let's say we want all
+     * [Int] columns apart from `age`  and  `height`.
+     *
+     * We can do:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsOf][org.jetbrains.kotlinx.dataframe.api.colsOf]`<`[Int][Int]`>() `[except][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.except]`  (age  `[and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]` height) }`
+     *
+     * which will 'subtract' the [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] created by `age `[and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]` height` from the [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] created by [colsOf][org.jetbrains.kotlinx.dataframe.api.colsOf]`<`[Int][Int]`>()`.
+     *
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * This operation can also be used to exclude columns from [Column Groups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * For instance:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsAtAnyDepth][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsAtAnyDepth]`  { "a"  `[in][String.contains]` it.`[name][org.jetbrains.kotlinx.dataframe.DataColumn.name]`() } `[except][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.except]` userData.age }`
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     * Note that the selection of columns to exclude from [column sets][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] is always done relative to the outer
+     * scope. Use the [Extension Properties API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi.ExtensionPropertiesApi] to prevent scoping issues if possible.
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * Special case: If a column that needs to be removed appears multiple times in the [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet], it is excepted
+     * each time it is encountered (including inside [ColumnGroups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup]). You could say the receiver [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]
+     * is [simplified][org.jetbrains.kotlinx.dataframe.api.SimplifyColumnsSelectionDsl.simplify] before the operation is performed:
+     *
+     * [cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`(a, a, a.b, a.b).`[except][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.except]`(a.b)`
+     *
+     * `== `[cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`(a).`[except][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.except]`(a.b)`
+     *
+     * ### In the [ColumnsSelectionDsl][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl]
+     * Instead of having to write [all][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.all]`() `[except][org.jetbrains.kotlinx.dataframe.api.AllExceptColumnsSelectionDsl.except]` { ... }` in the DSL,
+     * you can use [allExcept][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.allExcept]` { ... }` to achieve the same result.
+     *
+     * For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[allExcept][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.allExcept]`  { userData.age  `[and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]` height } }`
+     *
+     * ### On [ColumnGroups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup]
+     * The variant of this function on [ColumnGroups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup] is a bit different as it changes the scope relative to
+     * the column group.
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * In other words:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColGroup.`[allColsExcept][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.allColsExcept]`  { colA  `[and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]` colB } }`
+     *
+     * is shorthand for
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColGroup.`[select][org.jetbrains.kotlinx.dataframe.api.SelectColumnsSelectionDsl.select]`  {  `[all][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.all]`() `[except][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.except]`  { colA  `[and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]` colB } } }`
+     *
+     * or
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColGroup.`[allCols][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allCols]`() `[except][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.except]`  { myColGroup.colA  `[and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]` myColGroup.colB } }`
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * Also note the name change, similar to [allCols][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allCols], this makes it clearer that you're selecting
+     * columns inside the group, 'lifting' them out.
+     *
+     * ### Examples for this overload
+     *
+     *  `df.`[select][org.jetbrains.kotlinx.dataframe.api.SelectColumnsSelectionDsl.select]`  {  `<code>`DataSchemaPerson::userData.`</code>[allColsExcept][KProperty.allColsExcept]<code>`  { "age"  `[and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]` height }`</code>` }`
+     *
+     *  `df.`[select][org.jetbrains.kotlinx.dataframe.api.SelectColumnsSelectionDsl.select]`  { city  `[and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]` `<code>`Person::name.`</code>[allColsExcept][KProperty.allColsExcept]<code>` { firstName }`</code>` }`
+     *
+     * @param [selector] A lambda in which you specify the columns that need to be
+     *  excluded from the current selection in [this] column group. The other columns will be included in the selection
+     *  by default. The scope of the selector is relative to the column group.
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns in [this] except the specified ones.
+     * @see ColumnsSelectionDsl.select
+     * @see ColumnsSelectionDsl.all
+     * @see ColumnsSelectionDsl.allBefore
+     * @see ColumnsSelectionDsl.allAfter
+     * @see ColumnsSelectionDsl.allUpTo
+     * @see ColumnsSelectionDsl.allFrom
+     */
+    public fun <C> KProperty<C>.allColsExcept(selector: ColumnsSelector<C, *>): ColumnSet<*> =
+        columnGroup(this).allColsExcept(selector)
+
+    @Deprecated(
+        message = ALL_COLS_EXCEPT,
+        replaceWith = ReplaceWith(ALL_COLS_REPLACE),
+        level = DeprecationLevel.ERROR,
+    ) // present solely to redirect users to the right function
+    public fun KProperty<*>.allColsExcept(other: ColumnsResolver<*>): ColumnSet<*> =
+        allColsExcept { other }
+
+    @Deprecated(
+        message = ALL_COLS_EXCEPT,
+        replaceWith = ReplaceWith(ALL_COLS_REPLACE_VARARG),
+        level = DeprecationLevel.ERROR,
+    ) // present solely to redirect users to the right function
+    public fun KProperty<*>.allColsExcept(vararg others: ColumnsResolver<*>): ColumnSet<*> =
+        allColsExcept { others.toColumnSet() }
+
+    /**
+     * ## (All) (Cols) Except
+     *
+     * Perform a selection of columns using the [Columns Selection DSL][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl] to
+     * exclude from the current selection.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.AllExceptColumnsSelectionDsl.Grammar]
+     *
+     * ### On [ColumnSets][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]
+     * This function can be explained the easiest with [ColumnSets][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]. Let's say we want all
+     * [Int] columns apart from `age`  and  `height`.
+     *
+     * We can do:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsOf][org.jetbrains.kotlinx.dataframe.api.colsOf]`<`[Int][Int]`>() `[except][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.except]`  (age  `[and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]` height) }`
+     *
+     * which will 'subtract' the [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] created by `age `[and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]` height` from the [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] created by [colsOf][org.jetbrains.kotlinx.dataframe.api.colsOf]`<`[Int][Int]`>()`.
+     *
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * This operation can also be used to exclude columns from [Column Groups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * For instance:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsAtAnyDepth][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsAtAnyDepth]`  { "a"  `[in][String.contains]` it.`[name][org.jetbrains.kotlinx.dataframe.DataColumn.name]`() } `[except][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.except]` userData.age }`
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     * Note that the selection of columns to exclude from [column sets][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] is always done relative to the outer
+     * scope. Use the [Extension Properties API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi.ExtensionPropertiesApi] to prevent scoping issues if possible.
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * Special case: If a column that needs to be removed appears multiple times in the [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet], it is excepted
+     * each time it is encountered (including inside [ColumnGroups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup]). You could say the receiver [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]
+     * is [simplified][org.jetbrains.kotlinx.dataframe.api.SimplifyColumnsSelectionDsl.simplify] before the operation is performed:
+     *
+     * [cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`(a, a, a.b, a.b).`[except][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.except]`(a.b)`
+     *
+     * `== `[cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`(a).`[except][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.except]`(a.b)`
+     *
+     * ### In the [ColumnsSelectionDsl][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl]
+     * Instead of having to write [all][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.all]`() `[except][org.jetbrains.kotlinx.dataframe.api.AllExceptColumnsSelectionDsl.except]` { ... }` in the DSL,
+     * you can use [allExcept][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.allExcept]` { ... }` to achieve the same result.
+     *
+     * For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[allExcept][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.allExcept]`  { userData.age  `[and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]` height } }`
+     *
+     * ### On [ColumnGroups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup]
+     * The variant of this function on [ColumnGroups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup] is a bit different as it changes the scope relative to
+     * the column group.
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * In other words:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColGroup.`[allColsExcept][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.allColsExcept]`  { colA  `[and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]` colB } }`
+     *
+     * is shorthand for
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColGroup.`[select][org.jetbrains.kotlinx.dataframe.api.SelectColumnsSelectionDsl.select]`  {  `[all][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.all]`() `[except][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.except]`  { colA  `[and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]` colB } } }`
+     *
+     * or
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColGroup.`[allCols][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allCols]`() `[except][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.except]`  { myColGroup.colA  `[and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]` myColGroup.colB } }`
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * Also note the name change, similar to [allCols][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allCols], this makes it clearer that you're selecting
+     * columns inside the group, 'lifting' them out.
+     *
+     * ### Examples for this overload
+     *
+     *  `df.`[select][org.jetbrains.kotlinx.dataframe.api.SelectColumnsSelectionDsl.select]`  {  `<code>`DataSchemaPerson::userData.`</code>[allColsExcept][KProperty.allColsExcept]<code>`("age", "height")`</code>` }`
+     *
+     *  `df.`[select][org.jetbrains.kotlinx.dataframe.api.SelectColumnsSelectionDsl.select]`  { city  `[and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]` `<code>`Person::name.`</code>[allColsExcept][KProperty.allColsExcept]<code>`("firstName", "middleName")`</code>` }`
+     *
+     * @param [others] Any number of [Strings][String] referring to
+     *  the columns (relative to the column group) that need to be excluded from the current selection in [this]
+     *  column group. The other columns will be included in the selection by default.
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns in [this] except the specified ones.
+     * @see ColumnsSelectionDsl.select
+     * @see ColumnsSelectionDsl.all
+     * @see ColumnsSelectionDsl.allBefore
+     * @see ColumnsSelectionDsl.allAfter
+     * @see ColumnsSelectionDsl.allUpTo
+     * @see ColumnsSelectionDsl.allFrom
+     */
+    public fun KProperty<*>.allColsExcept(vararg others: String): ColumnSet<*> =
+        columnGroup(this).allColsExceptInternal(others.toColumnSet())
+
+    /**
+     * ## (All) (Cols) Except
+     *
+     * Perform a selection of columns using the [Columns Selection DSL][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl] to
+     * exclude from the current selection.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.AllExceptColumnsSelectionDsl.Grammar]
+     *
+     * ### On [ColumnSets][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]
+     * This function can be explained the easiest with [ColumnSets][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]. Let's say we want all
+     * [Int] columns apart from `age`  and  `height`.
+     *
+     * We can do:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsOf][org.jetbrains.kotlinx.dataframe.api.colsOf]`<`[Int][Int]`>() `[except][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.except]`  (age  `[and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]` height) }`
+     *
+     * which will 'subtract' the [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] created by `age `[and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]` height` from the [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] created by [colsOf][org.jetbrains.kotlinx.dataframe.api.colsOf]`<`[Int][Int]`>()`.
+     *
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * This operation can also be used to exclude columns from [Column Groups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * For instance:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsAtAnyDepth][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsAtAnyDepth]`  { "a"  `[in][String.contains]` it.`[name][org.jetbrains.kotlinx.dataframe.DataColumn.name]`() } `[except][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.except]` userData.age }`
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     * Note that the selection of columns to exclude from [column sets][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] is always done relative to the outer
+     * scope. Use the [Extension Properties API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi.ExtensionPropertiesApi] to prevent scoping issues if possible.
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * Special case: If a column that needs to be removed appears multiple times in the [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet], it is excepted
+     * each time it is encountered (including inside [ColumnGroups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup]). You could say the receiver [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]
+     * is [simplified][org.jetbrains.kotlinx.dataframe.api.SimplifyColumnsSelectionDsl.simplify] before the operation is performed:
+     *
+     * [cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`(a, a, a.b, a.b).`[except][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.except]`(a.b)`
+     *
+     * `== `[cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`(a).`[except][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.except]`(a.b)`
+     *
+     * ### In the [ColumnsSelectionDsl][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl]
+     * Instead of having to write [all][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.all]`() `[except][org.jetbrains.kotlinx.dataframe.api.AllExceptColumnsSelectionDsl.except]` { ... }` in the DSL,
+     * you can use [allExcept][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.allExcept]` { ... }` to achieve the same result.
+     *
+     * For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[allExcept][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.allExcept]`  { userData.age  `[and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]` height } }`
+     *
+     * ### On [ColumnGroups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup]
+     * The variant of this function on [ColumnGroups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup] is a bit different as it changes the scope relative to
+     * the column group.
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * In other words:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColGroup.`[allColsExcept][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.allColsExcept]`  { colA  `[and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]` colB } }`
+     *
+     * is shorthand for
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColGroup.`[select][org.jetbrains.kotlinx.dataframe.api.SelectColumnsSelectionDsl.select]`  {  `[all][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.all]`() `[except][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.except]`  { colA  `[and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]` colB } } }`
+     *
+     * or
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColGroup.`[allCols][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allCols]`() `[except][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.except]`  { myColGroup.colA  `[and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]` myColGroup.colB } }`
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * Also note the name change, similar to [allCols][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allCols], this makes it clearer that you're selecting
+     * columns inside the group, 'lifting' them out.
+     *
+     * ### Examples for this overload
+     *
+     *  `df.`[select][org.jetbrains.kotlinx.dataframe.api.SelectColumnsSelectionDsl.select]`  {  `<code>`DataSchemaPerson::userData.`</code>[allColsExcept][KProperty.allColsExcept]<code>`(Person::age, Person::height)`</code>` }`
+     *
+     *  `df.`[select][org.jetbrains.kotlinx.dataframe.api.SelectColumnsSelectionDsl.select]`  { city  `[and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]` `<code>`Person::name.`</code>[allColsExcept][KProperty.allColsExcept]<code>`(Person::firstName, Person::middleName)`</code>` }`
+     *
+     * @param [others] Any number of [KProperties][KProperty] referring to
+     *  the columns (relative to the column group) that need to be excluded from the current selection in [this]
+     *  column group. The other columns will be included in the selection by default.
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns in [this] except the specified ones.
+     * @see ColumnsSelectionDsl.select
+     * @see ColumnsSelectionDsl.all
+     * @see ColumnsSelectionDsl.allBefore
+     * @see ColumnsSelectionDsl.allAfter
+     * @see ColumnsSelectionDsl.allUpTo
+     * @see ColumnsSelectionDsl.allFrom
+     */
+    public fun KProperty<*>.allColsExcept(vararg others: KProperty<*>): ColumnSet<*> =
+        columnGroup(this).allColsExceptInternal(others.toColumnSet())
+
+    /**
+     * ## (All) (Cols) Except
+     *
+     * Perform a selection of columns using the [Columns Selection DSL][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl] to
+     * exclude from the current selection.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.AllExceptColumnsSelectionDsl.Grammar]
+     *
+     * ### On [ColumnSets][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]
+     * This function can be explained the easiest with [ColumnSets][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]. Let's say we want all
+     * [Int] columns apart from `age`  and  `height`.
+     *
+     * We can do:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsOf][org.jetbrains.kotlinx.dataframe.api.colsOf]`<`[Int][Int]`>() `[except][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.except]`  (age  `[and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]` height) }`
+     *
+     * which will 'subtract' the [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] created by `age `[and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]` height` from the [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] created by [colsOf][org.jetbrains.kotlinx.dataframe.api.colsOf]`<`[Int][Int]`>()`.
+     *
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * This operation can also be used to exclude columns from [Column Groups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * For instance:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsAtAnyDepth][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsAtAnyDepth]`  { "a"  `[in][String.contains]` it.`[name][org.jetbrains.kotlinx.dataframe.DataColumn.name]`() } `[except][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.except]` userData.age }`
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     * Note that the selection of columns to exclude from [column sets][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] is always done relative to the outer
+     * scope. Use the [Extension Properties API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi.ExtensionPropertiesApi] to prevent scoping issues if possible.
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * Special case: If a column that needs to be removed appears multiple times in the [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet], it is excepted
+     * each time it is encountered (including inside [ColumnGroups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup]). You could say the receiver [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]
+     * is [simplified][org.jetbrains.kotlinx.dataframe.api.SimplifyColumnsSelectionDsl.simplify] before the operation is performed:
+     *
+     * [cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`(a, a, a.b, a.b).`[except][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.except]`(a.b)`
+     *
+     * `== `[cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`(a).`[except][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.except]`(a.b)`
+     *
+     * ### In the [ColumnsSelectionDsl][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl]
+     * Instead of having to write [all][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.all]`() `[except][org.jetbrains.kotlinx.dataframe.api.AllExceptColumnsSelectionDsl.except]` { ... }` in the DSL,
+     * you can use [allExcept][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.allExcept]` { ... }` to achieve the same result.
+     *
+     * For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[allExcept][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.allExcept]`  { userData.age  `[and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]` height } }`
+     *
+     * ### On [ColumnGroups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup]
+     * The variant of this function on [ColumnGroups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup] is a bit different as it changes the scope relative to
+     * the column group.
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * In other words:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColGroup.`[allColsExcept][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.allColsExcept]`  { colA  `[and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]` colB } }`
+     *
+     * is shorthand for
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColGroup.`[select][org.jetbrains.kotlinx.dataframe.api.SelectColumnsSelectionDsl.select]`  {  `[all][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.all]`() `[except][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.except]`  { colA  `[and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]` colB } } }`
+     *
+     * or
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColGroup.`[allCols][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allCols]`() `[except][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.except]`  { myColGroup.colA  `[and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]` myColGroup.colB } }`
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * Also note the name change, similar to [allCols][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allCols], this makes it clearer that you're selecting
+     * columns inside the group, 'lifting' them out.
+     *
+     * ### Examples for this overload
+     *
+     *  `df.`[select][org.jetbrains.kotlinx.dataframe.api.SelectColumnsSelectionDsl.select]`  {  `<code>`DataSchemaPerson::userData.`</code>[allColsExcept][KProperty.allColsExcept]<code>`(pathOf("age"), "extraData"["item1"])`</code>` }`
+     *
+     *  `df.`[select][org.jetbrains.kotlinx.dataframe.api.SelectColumnsSelectionDsl.select]`  { city  `[and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]` `<code>`Person::name.`</code>[allColsExcept][KProperty.allColsExcept]<code>`(pathOf("firstName"), "middleNames"["first"])`</code>` }`
+     *
+     * @param [others] Any number of [ColumnPaths][org.jetbrains.kotlinx.dataframe.columns.ColumnPath] referring to
+     *  the columns (relative to the column group) that need to be excluded from the current selection in [this]
+     *  column group. The other columns will be included in the selection by default.
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns in [this] except the specified ones.
+     * @see ColumnsSelectionDsl.select
+     * @see ColumnsSelectionDsl.all
+     * @see ColumnsSelectionDsl.allBefore
+     * @see ColumnsSelectionDsl.allAfter
+     * @see ColumnsSelectionDsl.allUpTo
+     * @see ColumnsSelectionDsl.allFrom
+     */
+    public fun KProperty<*>.allColsExcept(vararg others: ColumnPath): ColumnSet<*> =
+        columnGroup(this).allColsExceptInternal(others.toColumnSet())
+
+    // endregion
+
+    // region ColumnPath
+
+    /**
+     * ## (All) (Cols) Except
+     *
+     * Perform a selection of columns using the [Columns Selection DSL][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl] to
+     * exclude from the current selection.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.AllExceptColumnsSelectionDsl.Grammar]
+     *
+     * ### On [ColumnSets][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]
+     * This function can be explained the easiest with [ColumnSets][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]. Let's say we want all
+     * [Int] columns apart from `age`  and  `height`.
+     *
+     * We can do:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsOf][org.jetbrains.kotlinx.dataframe.api.colsOf]`<`[Int][Int]`>() `[except][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.except]`  (age  `[and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]` height) }`
+     *
+     * which will 'subtract' the [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] created by `age `[and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]` height` from the [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] created by [colsOf][org.jetbrains.kotlinx.dataframe.api.colsOf]`<`[Int][Int]`>()`.
+     *
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * This operation can also be used to exclude columns from [Column Groups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * For instance:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsAtAnyDepth][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsAtAnyDepth]`  { "a"  `[in][String.contains]` it.`[name][org.jetbrains.kotlinx.dataframe.DataColumn.name]`() } `[except][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.except]` userData.age }`
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     * Note that the selection of columns to exclude from [column sets][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] is always done relative to the outer
+     * scope. Use the [Extension Properties API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi.ExtensionPropertiesApi] to prevent scoping issues if possible.
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * Special case: If a column that needs to be removed appears multiple times in the [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet], it is excepted
+     * each time it is encountered (including inside [ColumnGroups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup]). You could say the receiver [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]
+     * is [simplified][org.jetbrains.kotlinx.dataframe.api.SimplifyColumnsSelectionDsl.simplify] before the operation is performed:
+     *
+     * [cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`(a, a, a.b, a.b).`[except][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.except]`(a.b)`
+     *
+     * `== `[cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`(a).`[except][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.except]`(a.b)`
+     *
+     * ### In the [ColumnsSelectionDsl][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl]
+     * Instead of having to write [all][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.all]`() `[except][org.jetbrains.kotlinx.dataframe.api.AllExceptColumnsSelectionDsl.except]` { ... }` in the DSL,
+     * you can use [allExcept][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.allExcept]` { ... }` to achieve the same result.
+     *
+     * For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[allExcept][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.allExcept]`  { userData.age  `[and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]` height } }`
+     *
+     * ### On [ColumnGroups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup]
+     * The variant of this function on [ColumnGroups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup] is a bit different as it changes the scope relative to
+     * the column group.
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * In other words:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColGroup.`[allColsExcept][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.allColsExcept]`  { colA  `[and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]` colB } }`
+     *
+     * is shorthand for
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColGroup.`[select][org.jetbrains.kotlinx.dataframe.api.SelectColumnsSelectionDsl.select]`  {  `[all][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.all]`() `[except][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.except]`  { colA  `[and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]` colB } } }`
+     *
+     * or
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColGroup.`[allCols][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allCols]`() `[except][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.except]`  { myColGroup.colA  `[and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]` myColGroup.colB } }`
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * Also note the name change, similar to [allCols][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allCols], this makes it clearer that you're selecting
+     * columns inside the group, 'lifting' them out.
+     *
+     * ### Examples for this overload
+     *
+     *  `df.`[select][org.jetbrains.kotlinx.dataframe.api.SelectColumnsSelectionDsl.select]`  {  `<code>`pathOf("userData").`</code>[allColsExcept][ColumnPath.allColsExcept]<code>`  { "age"  `[and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]` height }`</code>` }`
+     *
+     *  `df.`[select][org.jetbrains.kotlinx.dataframe.api.SelectColumnsSelectionDsl.select]`  { city  `[and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]` `<code>`"pathTo"["myColGroup"].`</code>[allColsExcept][ColumnPath.allColsExcept]<code>` { firstName }`</code>` }`
+     *
+     * @param [selector] A lambda in which you specify the columns that need to be
+     *  excluded from the current selection in [this] column group. The other columns will be included in the selection
+     *  by default. The scope of the selector is relative to the column group.
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns in [this] except the specified ones.
+     * @see ColumnsSelectionDsl.select
+     * @see ColumnsSelectionDsl.all
+     * @see ColumnsSelectionDsl.allBefore
+     * @see ColumnsSelectionDsl.allAfter
+     * @see ColumnsSelectionDsl.allUpTo
+     * @see ColumnsSelectionDsl.allFrom
+     */
+    public fun ColumnPath.allColsExcept(selector: ColumnsSelector<*, *>): ColumnSet<*> =
+        columnGroup(this).allColsExcept(selector)
+
+    @Deprecated(
+        message = ALL_COLS_EXCEPT,
+        replaceWith = ReplaceWith(ALL_COLS_REPLACE),
+        level = DeprecationLevel.ERROR,
+    ) // present solely to redirect users to the right function
+    public fun ColumnPath.allColsExcept(other: ColumnsResolver<*>): ColumnSet<*> =
+        allColsExcept { other }
+
+    @Deprecated(
+        message = ALL_COLS_EXCEPT,
+        replaceWith = ReplaceWith(ALL_COLS_REPLACE_VARARG),
+        level = DeprecationLevel.ERROR,
+    ) // present solely to redirect users to the right function
+    public fun ColumnPath.allColsExcept(vararg others: ColumnsResolver<*>): ColumnSet<*> =
+        allColsExcept { others.toColumnSet() }
+
+    /**
+     * ## (All) (Cols) Except
+     *
+     * Perform a selection of columns using the [Columns Selection DSL][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl] to
+     * exclude from the current selection.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.AllExceptColumnsSelectionDsl.Grammar]
+     *
+     * ### On [ColumnSets][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]
+     * This function can be explained the easiest with [ColumnSets][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]. Let's say we want all
+     * [Int] columns apart from `age`  and  `height`.
+     *
+     * We can do:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsOf][org.jetbrains.kotlinx.dataframe.api.colsOf]`<`[Int][Int]`>() `[except][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.except]`  (age  `[and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]` height) }`
+     *
+     * which will 'subtract' the [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] created by `age `[and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]` height` from the [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] created by [colsOf][org.jetbrains.kotlinx.dataframe.api.colsOf]`<`[Int][Int]`>()`.
+     *
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * This operation can also be used to exclude columns from [Column Groups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * For instance:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsAtAnyDepth][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsAtAnyDepth]`  { "a"  `[in][String.contains]` it.`[name][org.jetbrains.kotlinx.dataframe.DataColumn.name]`() } `[except][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.except]` userData.age }`
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     * Note that the selection of columns to exclude from [column sets][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] is always done relative to the outer
+     * scope. Use the [Extension Properties API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi.ExtensionPropertiesApi] to prevent scoping issues if possible.
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * Special case: If a column that needs to be removed appears multiple times in the [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet], it is excepted
+     * each time it is encountered (including inside [ColumnGroups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup]). You could say the receiver [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]
+     * is [simplified][org.jetbrains.kotlinx.dataframe.api.SimplifyColumnsSelectionDsl.simplify] before the operation is performed:
+     *
+     * [cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`(a, a, a.b, a.b).`[except][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.except]`(a.b)`
+     *
+     * `== `[cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`(a).`[except][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.except]`(a.b)`
+     *
+     * ### In the [ColumnsSelectionDsl][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl]
+     * Instead of having to write [all][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.all]`() `[except][org.jetbrains.kotlinx.dataframe.api.AllExceptColumnsSelectionDsl.except]` { ... }` in the DSL,
+     * you can use [allExcept][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.allExcept]` { ... }` to achieve the same result.
+     *
+     * For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[allExcept][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.allExcept]`  { userData.age  `[and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]` height } }`
+     *
+     * ### On [ColumnGroups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup]
+     * The variant of this function on [ColumnGroups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup] is a bit different as it changes the scope relative to
+     * the column group.
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * In other words:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColGroup.`[allColsExcept][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.allColsExcept]`  { colA  `[and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]` colB } }`
+     *
+     * is shorthand for
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColGroup.`[select][org.jetbrains.kotlinx.dataframe.api.SelectColumnsSelectionDsl.select]`  {  `[all][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.all]`() `[except][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.except]`  { colA  `[and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]` colB } } }`
+     *
+     * or
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColGroup.`[allCols][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allCols]`() `[except][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.except]`  { myColGroup.colA  `[and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]` myColGroup.colB } }`
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * Also note the name change, similar to [allCols][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allCols], this makes it clearer that you're selecting
+     * columns inside the group, 'lifting' them out.
+     *
+     * ### Examples for this overload
+     *
+     *  `df.`[select][org.jetbrains.kotlinx.dataframe.api.SelectColumnsSelectionDsl.select]`  {  `<code>`pathOf("userData").`</code>[allColsExcept][ColumnPath.allColsExcept]<code>`("age", "height")`</code>` }`
+     *
+     *  `df.`[select][org.jetbrains.kotlinx.dataframe.api.SelectColumnsSelectionDsl.select]`  { city  `[and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]` `<code>`"pathTo"["myColGroup"].`</code>[allColsExcept][ColumnPath.allColsExcept]<code>`("firstName", "middleName")`</code>` }`
+     *
+     * @param [others] Any number of [Strings][String] referring to
+     *  the columns (relative to the column group) that need to be excluded from the current selection in [this]
+     *  column group. The other columns will be included in the selection by default.
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns in [this] except the specified ones.
+     * @see ColumnsSelectionDsl.select
+     * @see ColumnsSelectionDsl.all
+     * @see ColumnsSelectionDsl.allBefore
+     * @see ColumnsSelectionDsl.allAfter
+     * @see ColumnsSelectionDsl.allUpTo
+     * @see ColumnsSelectionDsl.allFrom
+     */
+    public fun ColumnPath.allColsExcept(vararg others: String): ColumnSet<*> =
+        columnGroup(this).allColsExceptInternal(others.toColumnSet())
+
+    /**
+     * ## (All) (Cols) Except
+     *
+     * Perform a selection of columns using the [Columns Selection DSL][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl] to
+     * exclude from the current selection.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.AllExceptColumnsSelectionDsl.Grammar]
+     *
+     * ### On [ColumnSets][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]
+     * This function can be explained the easiest with [ColumnSets][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]. Let's say we want all
+     * [Int] columns apart from `age`  and  `height`.
+     *
+     * We can do:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsOf][org.jetbrains.kotlinx.dataframe.api.colsOf]`<`[Int][Int]`>() `[except][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.except]`  (age  `[and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]` height) }`
+     *
+     * which will 'subtract' the [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] created by `age `[and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]` height` from the [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] created by [colsOf][org.jetbrains.kotlinx.dataframe.api.colsOf]`<`[Int][Int]`>()`.
+     *
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * This operation can also be used to exclude columns from [Column Groups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * For instance:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsAtAnyDepth][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsAtAnyDepth]`  { "a"  `[in][String.contains]` it.`[name][org.jetbrains.kotlinx.dataframe.DataColumn.name]`() } `[except][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.except]` userData.age }`
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     * Note that the selection of columns to exclude from [column sets][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] is always done relative to the outer
+     * scope. Use the [Extension Properties API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi.ExtensionPropertiesApi] to prevent scoping issues if possible.
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * Special case: If a column that needs to be removed appears multiple times in the [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet], it is excepted
+     * each time it is encountered (including inside [ColumnGroups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup]). You could say the receiver [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]
+     * is [simplified][org.jetbrains.kotlinx.dataframe.api.SimplifyColumnsSelectionDsl.simplify] before the operation is performed:
+     *
+     * [cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`(a, a, a.b, a.b).`[except][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.except]`(a.b)`
+     *
+     * `== `[cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`(a).`[except][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.except]`(a.b)`
+     *
+     * ### In the [ColumnsSelectionDsl][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl]
+     * Instead of having to write [all][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.all]`() `[except][org.jetbrains.kotlinx.dataframe.api.AllExceptColumnsSelectionDsl.except]` { ... }` in the DSL,
+     * you can use [allExcept][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.allExcept]` { ... }` to achieve the same result.
+     *
+     * For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[allExcept][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.allExcept]`  { userData.age  `[and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]` height } }`
+     *
+     * ### On [ColumnGroups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup]
+     * The variant of this function on [ColumnGroups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup] is a bit different as it changes the scope relative to
+     * the column group.
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * In other words:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColGroup.`[allColsExcept][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.allColsExcept]`  { colA  `[and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]` colB } }`
+     *
+     * is shorthand for
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColGroup.`[select][org.jetbrains.kotlinx.dataframe.api.SelectColumnsSelectionDsl.select]`  {  `[all][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.all]`() `[except][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.except]`  { colA  `[and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]` colB } } }`
+     *
+     * or
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColGroup.`[allCols][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allCols]`() `[except][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.except]`  { myColGroup.colA  `[and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]` myColGroup.colB } }`
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * Also note the name change, similar to [allCols][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allCols], this makes it clearer that you're selecting
+     * columns inside the group, 'lifting' them out.
+     *
+     * ### Examples for this overload
+     *
+     *  `df.`[select][org.jetbrains.kotlinx.dataframe.api.SelectColumnsSelectionDsl.select]`  {  `<code>`pathOf("userData").`</code>[allColsExcept][ColumnPath.allColsExcept]<code>`(Person::age, Person::height)`</code>` }`
+     *
+     *  `df.`[select][org.jetbrains.kotlinx.dataframe.api.SelectColumnsSelectionDsl.select]`  { city  `[and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]` `<code>`"pathTo"["myColGroup"].`</code>[allColsExcept][ColumnPath.allColsExcept]<code>`(Person::firstName, Person::middleName)`</code>` }`
+     *
+     * @param [others] Any number of [KProperties][KProperty] referring to
+     *  the columns (relative to the column group) that need to be excluded from the current selection in [this]
+     *  column group. The other columns will be included in the selection by default.
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns in [this] except the specified ones.
+     * @see ColumnsSelectionDsl.select
+     * @see ColumnsSelectionDsl.all
+     * @see ColumnsSelectionDsl.allBefore
+     * @see ColumnsSelectionDsl.allAfter
+     * @see ColumnsSelectionDsl.allUpTo
+     * @see ColumnsSelectionDsl.allFrom
+     */
+    public fun ColumnPath.allColsExcept(vararg others: KProperty<*>): ColumnSet<*> =
+        columnGroup(this).allColsExceptInternal(others.toColumnSet())
+
+    /**
+     * ## (All) (Cols) Except
+     *
+     * Perform a selection of columns using the [Columns Selection DSL][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl] to
+     * exclude from the current selection.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.AllExceptColumnsSelectionDsl.Grammar]
+     *
+     * ### On [ColumnSets][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]
+     * This function can be explained the easiest with [ColumnSets][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]. Let's say we want all
+     * [Int] columns apart from `age`  and  `height`.
+     *
+     * We can do:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsOf][org.jetbrains.kotlinx.dataframe.api.colsOf]`<`[Int][Int]`>() `[except][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.except]`  (age  `[and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]` height) }`
+     *
+     * which will 'subtract' the [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] created by `age `[and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]` height` from the [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] created by [colsOf][org.jetbrains.kotlinx.dataframe.api.colsOf]`<`[Int][Int]`>()`.
+     *
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * This operation can also be used to exclude columns from [Column Groups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * For instance:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsAtAnyDepth][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsAtAnyDepth]`  { "a"  `[in][String.contains]` it.`[name][org.jetbrains.kotlinx.dataframe.DataColumn.name]`() } `[except][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.except]` userData.age }`
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     * Note that the selection of columns to exclude from [column sets][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] is always done relative to the outer
+     * scope. Use the [Extension Properties API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi.ExtensionPropertiesApi] to prevent scoping issues if possible.
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * Special case: If a column that needs to be removed appears multiple times in the [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet], it is excepted
+     * each time it is encountered (including inside [ColumnGroups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup]). You could say the receiver [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]
+     * is [simplified][org.jetbrains.kotlinx.dataframe.api.SimplifyColumnsSelectionDsl.simplify] before the operation is performed:
+     *
+     * [cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`(a, a, a.b, a.b).`[except][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.except]`(a.b)`
+     *
+     * `== `[cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`(a).`[except][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.except]`(a.b)`
+     *
+     * ### In the [ColumnsSelectionDsl][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl]
+     * Instead of having to write [all][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.all]`() `[except][org.jetbrains.kotlinx.dataframe.api.AllExceptColumnsSelectionDsl.except]` { ... }` in the DSL,
+     * you can use [allExcept][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.allExcept]` { ... }` to achieve the same result.
+     *
+     * For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[allExcept][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.allExcept]`  { userData.age  `[and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]` height } }`
+     *
+     * ### On [ColumnGroups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup]
+     * The variant of this function on [ColumnGroups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup] is a bit different as it changes the scope relative to
+     * the column group.
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * In other words:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColGroup.`[allColsExcept][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.allColsExcept]`  { colA  `[and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]` colB } }`
+     *
+     * is shorthand for
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColGroup.`[select][org.jetbrains.kotlinx.dataframe.api.SelectColumnsSelectionDsl.select]`  {  `[all][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.all]`() `[except][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.except]`  { colA  `[and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]` colB } } }`
+     *
+     * or
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColGroup.`[allCols][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allCols]`() `[except][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.except]`  { myColGroup.colA  `[and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]` myColGroup.colB } }`
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * Also note the name change, similar to [allCols][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allCols], this makes it clearer that you're selecting
+     * columns inside the group, 'lifting' them out.
+     *
+     * ### Examples for this overload
+     *
+     *  `df.`[select][org.jetbrains.kotlinx.dataframe.api.SelectColumnsSelectionDsl.select]`  {  `<code>`pathOf("userData").`</code>[allColsExcept][ColumnPath.allColsExcept]<code>`(pathOf("age"), "extraData"["item1"])`</code>` }`
+     *
+     *  `df.`[select][org.jetbrains.kotlinx.dataframe.api.SelectColumnsSelectionDsl.select]`  { city  `[and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]` `<code>`"pathTo"["myColGroup"].`</code>[allColsExcept][ColumnPath.allColsExcept]<code>`(pathOf("firstName"), "middleNames"["first"])`</code>` }`
+     *
+     * @param [others] Any number of [ColumnPaths][org.jetbrains.kotlinx.dataframe.columns.ColumnPath] referring to
+     *  the columns (relative to the column group) that need to be excluded from the current selection in [this]
+     *  column group. The other columns will be included in the selection by default.
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns in [this] except the specified ones.
+     * @see ColumnsSelectionDsl.select
+     * @see ColumnsSelectionDsl.all
+     * @see ColumnsSelectionDsl.allBefore
+     * @see ColumnsSelectionDsl.allAfter
+     * @see ColumnsSelectionDsl.allUpTo
+     * @see ColumnsSelectionDsl.allFrom
+     */
+    public fun ColumnPath.allColsExcept(vararg others: ColumnPath): ColumnSet<*> =
+        columnGroup(this).allColsExceptInternal(others.toColumnSet())
+
+    // endregion
+
+    // region experiments
+
+    /**
+     * ## EXPERIMENTAL: Except on Column Group
+     *
+     * Selects the current column group itself, except for the specified columns. This is different from
+     * [allColsExcept] in that it does not 'lift' the columns out of the group, but instead selects the group itself.
+     *
+     * As usual, all overloads for each [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi] are available.
+     *
+     * These produce the same result:
+     *
+     * `df.`[select][DataFrame.select]`  {  `[cols][ColumnsSelectionDsl.cols]`(colGroup) `[except][ColumnSet.except]` colGroup.col }`
+     *
+     * `df.`[select][DataFrame.select]`  { colGroup  `[exceptNew][SingleColumn.except]` { col } }`
+     *
+     * These functions are experimental and may be removed or changed in the future.
+     *
+     * Trying these functions requires you to `@`[`OptIn`][OptIn]`(`[ExperimentalExceptCsDsl][ExperimentalExceptCsDsl]`::class)` first.
+     *
+     * ## NOTE:
+     * `exceptNew` will likely be renamed to `except` when the deprecated [SingleColumn.except] functions
+     * are deleted.
+     */
+    private interface ExperimentalExceptDocs
+
+    /**
+     * ## EXPERIMENTAL: Except on Column Group
+     *
+     * Selects the current column group itself, except for the specified columns. This is different from
+     * [allColsExcept][org.jetbrains.kotlinx.dataframe.api.AllExceptColumnsSelectionDsl.allColsExcept] in that it does not 'lift' the columns out of the group, but instead selects the group itself.
+     *
+     * As usual, all overloads for each [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi] are available.
+     *
+     * These produce the same result:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`(colGroup) `[except][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.except]` colGroup.col }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  { colGroup  `[exceptNew][SingleColumn.except]` { col } }`
+     *
+     * These functions are experimental and may be removed or changed in the future.
+     *
+     * Trying these functions requires you to `@`[`OptIn`][OptIn]`(`[ExperimentalExceptCsDsl][org.jetbrains.kotlinx.dataframe.api.ExperimentalExceptCsDsl]`::class)` first.
+     *
+     * ## NOTE:
+     * `exceptNew` will likely be renamed to `except` when the deprecated [SingleColumn.except] functions
+     * are deleted.
+     */
+    @ExperimentalExceptCsDsl
+    public infix fun <C> SingleColumn<DataRow<C>>.exceptNew(selector: ColumnsSelector<C, *>): SingleColumn<DataRow<C>> =
+        exceptExperimentalInternal(selector.toColumns())
+
+    @ExperimentalExceptCsDsl
+    @Deprecated(
+        message = ALL_COLS_EXCEPT,
+        replaceWith = ReplaceWith("exceptNew { other }"),
+        level = DeprecationLevel.ERROR,
+    ) // present solely to redirect users to the right function
+    public infix fun <C> SingleColumn<DataRow<C>>.exceptNew(other: ColumnsResolver<*>): SingleColumn<DataRow<C>> =
+        exceptNew { other }
+
+    @ExperimentalExceptCsDsl
+    @Deprecated(
+        message = ALL_COLS_EXCEPT,
+        replaceWith = ReplaceWith("exceptNew { others.toColumnSet() }"),
+        level = DeprecationLevel.ERROR,
+    ) // present solely to redirect users to the right function
+    public fun <C> SingleColumn<DataRow<C>>.exceptNew(vararg others: ColumnsResolver<*>): SingleColumn<DataRow<C>> =
+        exceptNew { others.toColumnSet() }
+
+    /**
+     * ## EXPERIMENTAL: Except on Column Group
+     *
+     * Selects the current column group itself, except for the specified columns. This is different from
+     * [allColsExcept][org.jetbrains.kotlinx.dataframe.api.AllExceptColumnsSelectionDsl.allColsExcept] in that it does not 'lift' the columns out of the group, but instead selects the group itself.
+     *
+     * As usual, all overloads for each [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi] are available.
+     *
+     * These produce the same result:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`(colGroup) `[except][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.except]` colGroup.col }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  { colGroup  `[exceptNew][SingleColumn.except]` { col } }`
+     *
+     * These functions are experimental and may be removed or changed in the future.
+     *
+     * Trying these functions requires you to `@`[`OptIn`][OptIn]`(`[ExperimentalExceptCsDsl][org.jetbrains.kotlinx.dataframe.api.ExperimentalExceptCsDsl]`::class)` first.
+     *
+     * ## NOTE:
+     * `exceptNew` will likely be renamed to `except` when the deprecated [SingleColumn.except] functions
+     * are deleted.
+     */
+    @ExperimentalExceptCsDsl
+    public infix fun <C> SingleColumn<DataRow<C>>.exceptNew(other: String): SingleColumn<DataRow<C>> =
+        exceptExperimentalInternal(column<Any?>(other))
+
+    /**
+     * ## EXPERIMENTAL: Except on Column Group
+     *
+     * Selects the current column group itself, except for the specified columns. This is different from
+     * [allColsExcept][org.jetbrains.kotlinx.dataframe.api.AllExceptColumnsSelectionDsl.allColsExcept] in that it does not 'lift' the columns out of the group, but instead selects the group itself.
+     *
+     * As usual, all overloads for each [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi] are available.
+     *
+     * These produce the same result:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`(colGroup) `[except][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.except]` colGroup.col }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  { colGroup  `[exceptNew][SingleColumn.except]` { col } }`
+     *
+     * These functions are experimental and may be removed or changed in the future.
+     *
+     * Trying these functions requires you to `@`[`OptIn`][OptIn]`(`[ExperimentalExceptCsDsl][org.jetbrains.kotlinx.dataframe.api.ExperimentalExceptCsDsl]`::class)` first.
+     *
+     * ## NOTE:
+     * `exceptNew` will likely be renamed to `except` when the deprecated [SingleColumn.except] functions
+     * are deleted.
+     */
+    @ExperimentalExceptCsDsl
+    public fun <C> SingleColumn<DataRow<C>>.exceptNew(vararg others: String): SingleColumn<DataRow<C>> =
+        exceptExperimentalInternal(others.toColumnSet())
+
+    /**
+     * ## EXPERIMENTAL: Except on Column Group
+     *
+     * Selects the current column group itself, except for the specified columns. This is different from
+     * [allColsExcept][org.jetbrains.kotlinx.dataframe.api.AllExceptColumnsSelectionDsl.allColsExcept] in that it does not 'lift' the columns out of the group, but instead selects the group itself.
+     *
+     * As usual, all overloads for each [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi] are available.
+     *
+     * These produce the same result:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`(colGroup) `[except][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.except]` colGroup.col }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  { colGroup  `[exceptNew][SingleColumn.except]` { col } }`
+     *
+     * These functions are experimental and may be removed or changed in the future.
+     *
+     * Trying these functions requires you to `@`[`OptIn`][OptIn]`(`[ExperimentalExceptCsDsl][org.jetbrains.kotlinx.dataframe.api.ExperimentalExceptCsDsl]`::class)` first.
+     *
+     * ## NOTE:
+     * `exceptNew` will likely be renamed to `except` when the deprecated [SingleColumn.except] functions
+     * are deleted.
+     */
+    @ExperimentalExceptCsDsl
+    public infix fun <C> SingleColumn<DataRow<C>>.exceptNew(other: KProperty<C>): SingleColumn<DataRow<C>> =
+        exceptExperimentalInternal(column(other))
+
+    /**
+     * ## EXPERIMENTAL: Except on Column Group
+     *
+     * Selects the current column group itself, except for the specified columns. This is different from
+     * [allColsExcept][org.jetbrains.kotlinx.dataframe.api.AllExceptColumnsSelectionDsl.allColsExcept] in that it does not 'lift' the columns out of the group, but instead selects the group itself.
+     *
+     * As usual, all overloads for each [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi] are available.
+     *
+     * These produce the same result:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`(colGroup) `[except][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.except]` colGroup.col }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  { colGroup  `[exceptNew][SingleColumn.except]` { col } }`
+     *
+     * These functions are experimental and may be removed or changed in the future.
+     *
+     * Trying these functions requires you to `@`[`OptIn`][OptIn]`(`[ExperimentalExceptCsDsl][org.jetbrains.kotlinx.dataframe.api.ExperimentalExceptCsDsl]`::class)` first.
+     *
+     * ## NOTE:
+     * `exceptNew` will likely be renamed to `except` when the deprecated [SingleColumn.except] functions
+     * are deleted.
+     */
+    @ExperimentalExceptCsDsl
+    public fun <C> SingleColumn<DataRow<C>>.exceptNew(vararg others: KProperty<*>): SingleColumn<DataRow<C>> =
+        exceptExperimentalInternal(others.toColumnSet())
+
+    /**
+     * ## EXPERIMENTAL: Except on Column Group
+     *
+     * Selects the current column group itself, except for the specified columns. This is different from
+     * [allColsExcept][org.jetbrains.kotlinx.dataframe.api.AllExceptColumnsSelectionDsl.allColsExcept] in that it does not 'lift' the columns out of the group, but instead selects the group itself.
+     *
+     * As usual, all overloads for each [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi] are available.
+     *
+     * These produce the same result:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`(colGroup) `[except][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.except]` colGroup.col }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  { colGroup  `[exceptNew][SingleColumn.except]` { col } }`
+     *
+     * These functions are experimental and may be removed or changed in the future.
+     *
+     * Trying these functions requires you to `@`[`OptIn`][OptIn]`(`[ExperimentalExceptCsDsl][org.jetbrains.kotlinx.dataframe.api.ExperimentalExceptCsDsl]`::class)` first.
+     *
+     * ## NOTE:
+     * `exceptNew` will likely be renamed to `except` when the deprecated [SingleColumn.except] functions
+     * are deleted.
+     */
+    @ExperimentalExceptCsDsl
+    public infix fun <C> SingleColumn<DataRow<C>>.exceptNew(other: ColumnPath): SingleColumn<DataRow<C>> =
+        exceptExperimentalInternal(column<Any?>(other))
+
+    /**
+     * ## EXPERIMENTAL: Except on Column Group
+     *
+     * Selects the current column group itself, except for the specified columns. This is different from
+     * [allColsExcept][org.jetbrains.kotlinx.dataframe.api.AllExceptColumnsSelectionDsl.allColsExcept] in that it does not 'lift' the columns out of the group, but instead selects the group itself.
+     *
+     * As usual, all overloads for each [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi] are available.
+     *
+     * These produce the same result:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`(colGroup) `[except][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.except]` colGroup.col }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  { colGroup  `[exceptNew][SingleColumn.except]` { col } }`
+     *
+     * These functions are experimental and may be removed or changed in the future.
+     *
+     * Trying these functions requires you to `@`[`OptIn`][OptIn]`(`[ExperimentalExceptCsDsl][org.jetbrains.kotlinx.dataframe.api.ExperimentalExceptCsDsl]`::class)` first.
+     *
+     * ## NOTE:
+     * `exceptNew` will likely be renamed to `except` when the deprecated [SingleColumn.except] functions
+     * are deleted.
+     */
+    @ExperimentalExceptCsDsl
+    public fun <C> SingleColumn<DataRow<C>>.exceptNew(vararg others: ColumnPath): SingleColumn<DataRow<C>> =
+        exceptExperimentalInternal(others.toColumnSet())
+
+    /**
+     * ## EXPERIMENTAL: Except on Column Group
+     *
+     * Selects the current column group itself, except for the specified columns. This is different from
+     * [allColsExcept][org.jetbrains.kotlinx.dataframe.api.AllExceptColumnsSelectionDsl.allColsExcept] in that it does not 'lift' the columns out of the group, but instead selects the group itself.
+     *
+     * As usual, all overloads for each [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi] are available.
+     *
+     * These produce the same result:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`(colGroup) `[except][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.except]` colGroup.col }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  { colGroup  `[exceptNew][SingleColumn.except]` { col } }`
+     *
+     * These functions are experimental and may be removed or changed in the future.
+     *
+     * Trying these functions requires you to `@`[`OptIn`][OptIn]`(`[ExperimentalExceptCsDsl][org.jetbrains.kotlinx.dataframe.api.ExperimentalExceptCsDsl]`::class)` first.
+     *
+     * ## NOTE:
+     * `exceptNew` will likely be renamed to `except` when the deprecated [SingleColumn.except] functions
+     * are deleted.
+     */
+    @ExperimentalExceptCsDsl
+    public infix fun String.exceptNew(selector: ColumnsSelector<*, *>): SingleColumn<DataRow<*>> =
+        columnGroup(this).exceptNew(selector)
+
+    @ExperimentalExceptCsDsl
+    @Deprecated(
+        message = ALL_COLS_EXCEPT,
+        replaceWith = ReplaceWith("exceptNew { other }"),
+        level = DeprecationLevel.ERROR,
+    ) // present solely to redirect users to the right function
+    public infix fun String.exceptNew(other: ColumnsResolver<*>): SingleColumn<DataRow<*>> =
+        exceptNew { other }
+
+    @ExperimentalExceptCsDsl
+    @Deprecated(
+        message = ALL_COLS_EXCEPT,
+        replaceWith = ReplaceWith("exceptNew { others.toColumnSet() }"),
+        level = DeprecationLevel.ERROR,
+    ) // present solely to redirect users to the right function
+    public fun String.exceptNew(vararg others: ColumnsResolver<*>): SingleColumn<DataRow<*>> =
+        exceptNew { others.toColumnSet() }
+
+    /**
+     * ## EXPERIMENTAL: Except on Column Group
+     *
+     * Selects the current column group itself, except for the specified columns. This is different from
+     * [allColsExcept][org.jetbrains.kotlinx.dataframe.api.AllExceptColumnsSelectionDsl.allColsExcept] in that it does not 'lift' the columns out of the group, but instead selects the group itself.
+     *
+     * As usual, all overloads for each [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi] are available.
+     *
+     * These produce the same result:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`(colGroup) `[except][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.except]` colGroup.col }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  { colGroup  `[exceptNew][SingleColumn.except]` { col } }`
+     *
+     * These functions are experimental and may be removed or changed in the future.
+     *
+     * Trying these functions requires you to `@`[`OptIn`][OptIn]`(`[ExperimentalExceptCsDsl][org.jetbrains.kotlinx.dataframe.api.ExperimentalExceptCsDsl]`::class)` first.
+     *
+     * ## NOTE:
+     * `exceptNew` will likely be renamed to `except` when the deprecated [SingleColumn.except] functions
+     * are deleted.
+     */
+    @ExperimentalExceptCsDsl
+    public infix fun String.exceptNew(other: String): SingleColumn<DataRow<*>> =
+        columnGroup(this).exceptExperimentalInternal(column<Any?>(other))
+
+    /**
+     * ## EXPERIMENTAL: Except on Column Group
+     *
+     * Selects the current column group itself, except for the specified columns. This is different from
+     * [allColsExcept][org.jetbrains.kotlinx.dataframe.api.AllExceptColumnsSelectionDsl.allColsExcept] in that it does not 'lift' the columns out of the group, but instead selects the group itself.
+     *
+     * As usual, all overloads for each [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi] are available.
+     *
+     * These produce the same result:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`(colGroup) `[except][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.except]` colGroup.col }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  { colGroup  `[exceptNew][SingleColumn.except]` { col } }`
+     *
+     * These functions are experimental and may be removed or changed in the future.
+     *
+     * Trying these functions requires you to `@`[`OptIn`][OptIn]`(`[ExperimentalExceptCsDsl][org.jetbrains.kotlinx.dataframe.api.ExperimentalExceptCsDsl]`::class)` first.
+     *
+     * ## NOTE:
+     * `exceptNew` will likely be renamed to `except` when the deprecated [SingleColumn.except] functions
+     * are deleted.
+     */
+    @ExperimentalExceptCsDsl
+    public fun String.exceptNew(vararg others: String): SingleColumn<DataRow<*>> =
+        columnGroup(this).exceptExperimentalInternal(others.toColumnSet())
+
+    /**
+     * ## EXPERIMENTAL: Except on Column Group
+     *
+     * Selects the current column group itself, except for the specified columns. This is different from
+     * [allColsExcept][org.jetbrains.kotlinx.dataframe.api.AllExceptColumnsSelectionDsl.allColsExcept] in that it does not 'lift' the columns out of the group, but instead selects the group itself.
+     *
+     * As usual, all overloads for each [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi] are available.
+     *
+     * These produce the same result:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`(colGroup) `[except][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.except]` colGroup.col }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  { colGroup  `[exceptNew][SingleColumn.except]` { col } }`
+     *
+     * These functions are experimental and may be removed or changed in the future.
+     *
+     * Trying these functions requires you to `@`[`OptIn`][OptIn]`(`[ExperimentalExceptCsDsl][org.jetbrains.kotlinx.dataframe.api.ExperimentalExceptCsDsl]`::class)` first.
+     *
+     * ## NOTE:
+     * `exceptNew` will likely be renamed to `except` when the deprecated [SingleColumn.except] functions
+     * are deleted.
+     */
+    @ExperimentalExceptCsDsl
+    public infix fun String.exceptNew(other: KProperty<*>): SingleColumn<DataRow<*>> =
+        columnGroup(this).exceptExperimentalInternal(column(other))
+
+    /**
+     * ## EXPERIMENTAL: Except on Column Group
+     *
+     * Selects the current column group itself, except for the specified columns. This is different from
+     * [allColsExcept][org.jetbrains.kotlinx.dataframe.api.AllExceptColumnsSelectionDsl.allColsExcept] in that it does not 'lift' the columns out of the group, but instead selects the group itself.
+     *
+     * As usual, all overloads for each [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi] are available.
+     *
+     * These produce the same result:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`(colGroup) `[except][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.except]` colGroup.col }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  { colGroup  `[exceptNew][SingleColumn.except]` { col } }`
+     *
+     * These functions are experimental and may be removed or changed in the future.
+     *
+     * Trying these functions requires you to `@`[`OptIn`][OptIn]`(`[ExperimentalExceptCsDsl][org.jetbrains.kotlinx.dataframe.api.ExperimentalExceptCsDsl]`::class)` first.
+     *
+     * ## NOTE:
+     * `exceptNew` will likely be renamed to `except` when the deprecated [SingleColumn.except] functions
+     * are deleted.
+     */
+    @ExperimentalExceptCsDsl
+    public fun String.exceptNew(vararg others: KProperty<*>): SingleColumn<DataRow<*>> =
+        columnGroup(this).exceptExperimentalInternal(others.toColumnSet())
+
+    /**
+     * ## EXPERIMENTAL: Except on Column Group
+     *
+     * Selects the current column group itself, except for the specified columns. This is different from
+     * [allColsExcept][org.jetbrains.kotlinx.dataframe.api.AllExceptColumnsSelectionDsl.allColsExcept] in that it does not 'lift' the columns out of the group, but instead selects the group itself.
+     *
+     * As usual, all overloads for each [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi] are available.
+     *
+     * These produce the same result:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`(colGroup) `[except][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.except]` colGroup.col }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  { colGroup  `[exceptNew][SingleColumn.except]` { col } }`
+     *
+     * These functions are experimental and may be removed or changed in the future.
+     *
+     * Trying these functions requires you to `@`[`OptIn`][OptIn]`(`[ExperimentalExceptCsDsl][org.jetbrains.kotlinx.dataframe.api.ExperimentalExceptCsDsl]`::class)` first.
+     *
+     * ## NOTE:
+     * `exceptNew` will likely be renamed to `except` when the deprecated [SingleColumn.except] functions
+     * are deleted.
+     */
+    @ExperimentalExceptCsDsl
+    public infix fun String.exceptNew(other: ColumnPath): SingleColumn<DataRow<*>> =
+        columnGroup(this).exceptExperimentalInternal(column<Any?>(other))
+
+    /**
+     * ## EXPERIMENTAL: Except on Column Group
+     *
+     * Selects the current column group itself, except for the specified columns. This is different from
+     * [allColsExcept][org.jetbrains.kotlinx.dataframe.api.AllExceptColumnsSelectionDsl.allColsExcept] in that it does not 'lift' the columns out of the group, but instead selects the group itself.
+     *
+     * As usual, all overloads for each [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi] are available.
+     *
+     * These produce the same result:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`(colGroup) `[except][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.except]` colGroup.col }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  { colGroup  `[exceptNew][SingleColumn.except]` { col } }`
+     *
+     * These functions are experimental and may be removed or changed in the future.
+     *
+     * Trying these functions requires you to `@`[`OptIn`][OptIn]`(`[ExperimentalExceptCsDsl][org.jetbrains.kotlinx.dataframe.api.ExperimentalExceptCsDsl]`::class)` first.
+     *
+     * ## NOTE:
+     * `exceptNew` will likely be renamed to `except` when the deprecated [SingleColumn.except] functions
+     * are deleted.
+     */
+    @ExperimentalExceptCsDsl
+    public fun String.exceptNew(vararg others: ColumnPath): SingleColumn<DataRow<*>> =
+        columnGroup(this).exceptExperimentalInternal(others.toColumnSet())
+
+    /**
+     * ## EXPERIMENTAL: Except on Column Group
+     *
+     * Selects the current column group itself, except for the specified columns. This is different from
+     * [allColsExcept][org.jetbrains.kotlinx.dataframe.api.AllExceptColumnsSelectionDsl.allColsExcept] in that it does not 'lift' the columns out of the group, but instead selects the group itself.
+     *
+     * As usual, all overloads for each [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi] are available.
+     *
+     * These produce the same result:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`(colGroup) `[except][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.except]` colGroup.col }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  { colGroup  `[exceptNew][SingleColumn.except]` { col } }`
+     *
+     * These functions are experimental and may be removed or changed in the future.
+     *
+     * Trying these functions requires you to `@`[`OptIn`][OptIn]`(`[ExperimentalExceptCsDsl][org.jetbrains.kotlinx.dataframe.api.ExperimentalExceptCsDsl]`::class)` first.
+     *
+     * ## NOTE:
+     * `exceptNew` will likely be renamed to `except` when the deprecated [SingleColumn.except] functions
+     * are deleted.
+     */
+    @ExperimentalExceptCsDsl
+    public infix fun <C> KProperty<C>.exceptNew(selector: ColumnsSelector<C, *>): SingleColumn<DataRow<C>> =
+        columnGroup(this).exceptExperimentalInternal(selector.toColumns())
+
+    @ExperimentalExceptCsDsl
+    @Deprecated(
+        message = ALL_COLS_EXCEPT,
+        replaceWith = ReplaceWith("exceptNew { other }"),
+        level = DeprecationLevel.ERROR,
+    ) // present solely to redirect users to the right function
+    public infix fun KProperty<*>.exceptNew(other: ColumnsResolver<*>): SingleColumn<DataRow<*>> =
+        exceptNew { other }
+
+    @ExperimentalExceptCsDsl
+    @Deprecated(
+        message = ALL_COLS_EXCEPT,
+        replaceWith = ReplaceWith("exceptNew { others.toColumnSet() }"),
+        level = DeprecationLevel.ERROR,
+    ) // present solely to redirect users to the right function
+    public fun KProperty<*>.exceptNew(vararg others: ColumnsResolver<*>): SingleColumn<DataRow<*>> =
+        exceptNew { others.toColumnSet() }
+
+    /**
+     * ## EXPERIMENTAL: Except on Column Group
+     *
+     * Selects the current column group itself, except for the specified columns. This is different from
+     * [allColsExcept][org.jetbrains.kotlinx.dataframe.api.AllExceptColumnsSelectionDsl.allColsExcept] in that it does not 'lift' the columns out of the group, but instead selects the group itself.
+     *
+     * As usual, all overloads for each [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi] are available.
+     *
+     * These produce the same result:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`(colGroup) `[except][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.except]` colGroup.col }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  { colGroup  `[exceptNew][SingleColumn.except]` { col } }`
+     *
+     * These functions are experimental and may be removed or changed in the future.
+     *
+     * Trying these functions requires you to `@`[`OptIn`][OptIn]`(`[ExperimentalExceptCsDsl][org.jetbrains.kotlinx.dataframe.api.ExperimentalExceptCsDsl]`::class)` first.
+     *
+     * ## NOTE:
+     * `exceptNew` will likely be renamed to `except` when the deprecated [SingleColumn.except] functions
+     * are deleted.
+     */
+    @ExperimentalExceptCsDsl
+    public infix fun <C> KProperty<C>.exceptNew(other: String): SingleColumn<DataRow<C>> =
+        columnGroup(this).exceptExperimentalInternal(column<Any?>(other))
+
+    /**
+     * ## EXPERIMENTAL: Except on Column Group
+     *
+     * Selects the current column group itself, except for the specified columns. This is different from
+     * [allColsExcept][org.jetbrains.kotlinx.dataframe.api.AllExceptColumnsSelectionDsl.allColsExcept] in that it does not 'lift' the columns out of the group, but instead selects the group itself.
+     *
+     * As usual, all overloads for each [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi] are available.
+     *
+     * These produce the same result:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`(colGroup) `[except][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.except]` colGroup.col }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  { colGroup  `[exceptNew][SingleColumn.except]` { col } }`
+     *
+     * These functions are experimental and may be removed or changed in the future.
+     *
+     * Trying these functions requires you to `@`[`OptIn`][OptIn]`(`[ExperimentalExceptCsDsl][org.jetbrains.kotlinx.dataframe.api.ExperimentalExceptCsDsl]`::class)` first.
+     *
+     * ## NOTE:
+     * `exceptNew` will likely be renamed to `except` when the deprecated [SingleColumn.except] functions
+     * are deleted.
+     */
+    @ExperimentalExceptCsDsl
+    public fun <C> KProperty<C>.exceptNew(vararg others: String): SingleColumn<DataRow<C>> =
+        columnGroup(this).exceptExperimentalInternal(others.toColumnSet())
+
+    /**
+     * ## EXPERIMENTAL: Except on Column Group
+     *
+     * Selects the current column group itself, except for the specified columns. This is different from
+     * [allColsExcept][org.jetbrains.kotlinx.dataframe.api.AllExceptColumnsSelectionDsl.allColsExcept] in that it does not 'lift' the columns out of the group, but instead selects the group itself.
+     *
+     * As usual, all overloads for each [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi] are available.
+     *
+     * These produce the same result:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`(colGroup) `[except][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.except]` colGroup.col }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  { colGroup  `[exceptNew][SingleColumn.except]` { col } }`
+     *
+     * These functions are experimental and may be removed or changed in the future.
+     *
+     * Trying these functions requires you to `@`[`OptIn`][OptIn]`(`[ExperimentalExceptCsDsl][org.jetbrains.kotlinx.dataframe.api.ExperimentalExceptCsDsl]`::class)` first.
+     *
+     * ## NOTE:
+     * `exceptNew` will likely be renamed to `except` when the deprecated [SingleColumn.except] functions
+     * are deleted.
+     */
+    @ExperimentalExceptCsDsl
+    @Suppress("INAPPLICABLE_JVM_NAME")
+    @JvmName("KPropertyDataRowExceptNew")
+    public infix fun <C> KProperty<DataRow<C>>.exceptNew(other: String): SingleColumn<DataRow<C>> =
+        columnGroup(this).exceptExperimentalInternal(column<Any?>(other))
+
+    /**
+     * ## EXPERIMENTAL: Except on Column Group
+     *
+     * Selects the current column group itself, except for the specified columns. This is different from
+     * [allColsExcept][org.jetbrains.kotlinx.dataframe.api.AllExceptColumnsSelectionDsl.allColsExcept] in that it does not 'lift' the columns out of the group, but instead selects the group itself.
+     *
+     * As usual, all overloads for each [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi] are available.
+     *
+     * These produce the same result:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`(colGroup) `[except][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.except]` colGroup.col }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  { colGroup  `[exceptNew][SingleColumn.except]` { col } }`
+     *
+     * These functions are experimental and may be removed or changed in the future.
+     *
+     * Trying these functions requires you to `@`[`OptIn`][OptIn]`(`[ExperimentalExceptCsDsl][org.jetbrains.kotlinx.dataframe.api.ExperimentalExceptCsDsl]`::class)` first.
+     *
+     * ## NOTE:
+     * `exceptNew` will likely be renamed to `except` when the deprecated [SingleColumn.except] functions
+     * are deleted.
+     */
+    @ExperimentalExceptCsDsl
+    @Suppress("INAPPLICABLE_JVM_NAME")
+    @JvmName("KPropertyDataRowExceptNew")
+    public fun <C> KProperty<DataRow<C>>.exceptNew(vararg others: String): SingleColumn<DataRow<C>> =
+        columnGroup(this).exceptExperimentalInternal(others.toColumnSet())
+
+    /**
+     * ## EXPERIMENTAL: Except on Column Group
+     *
+     * Selects the current column group itself, except for the specified columns. This is different from
+     * [allColsExcept][org.jetbrains.kotlinx.dataframe.api.AllExceptColumnsSelectionDsl.allColsExcept] in that it does not 'lift' the columns out of the group, but instead selects the group itself.
+     *
+     * As usual, all overloads for each [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi] are available.
+     *
+     * These produce the same result:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`(colGroup) `[except][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.except]` colGroup.col }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  { colGroup  `[exceptNew][SingleColumn.except]` { col } }`
+     *
+     * These functions are experimental and may be removed or changed in the future.
+     *
+     * Trying these functions requires you to `@`[`OptIn`][OptIn]`(`[ExperimentalExceptCsDsl][org.jetbrains.kotlinx.dataframe.api.ExperimentalExceptCsDsl]`::class)` first.
+     *
+     * ## NOTE:
+     * `exceptNew` will likely be renamed to `except` when the deprecated [SingleColumn.except] functions
+     * are deleted.
+     */
+    @ExperimentalExceptCsDsl
+    public infix fun <C> KProperty<C>.exceptNew(other: KProperty<*>): SingleColumn<DataRow<C>> =
+        columnGroup(this).exceptExperimentalInternal(column(other))
+
+    /**
+     * ## EXPERIMENTAL: Except on Column Group
+     *
+     * Selects the current column group itself, except for the specified columns. This is different from
+     * [allColsExcept][org.jetbrains.kotlinx.dataframe.api.AllExceptColumnsSelectionDsl.allColsExcept] in that it does not 'lift' the columns out of the group, but instead selects the group itself.
+     *
+     * As usual, all overloads for each [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi] are available.
+     *
+     * These produce the same result:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`(colGroup) `[except][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.except]` colGroup.col }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  { colGroup  `[exceptNew][SingleColumn.except]` { col } }`
+     *
+     * These functions are experimental and may be removed or changed in the future.
+     *
+     * Trying these functions requires you to `@`[`OptIn`][OptIn]`(`[ExperimentalExceptCsDsl][org.jetbrains.kotlinx.dataframe.api.ExperimentalExceptCsDsl]`::class)` first.
+     *
+     * ## NOTE:
+     * `exceptNew` will likely be renamed to `except` when the deprecated [SingleColumn.except] functions
+     * are deleted.
+     */
+    @ExperimentalExceptCsDsl
+    public fun <C> KProperty<C>.exceptNew(vararg others: KProperty<*>): SingleColumn<DataRow<C>> =
+        columnGroup(this).exceptExperimentalInternal(others.toColumnSet())
+
+    /**
+     * ## EXPERIMENTAL: Except on Column Group
+     *
+     * Selects the current column group itself, except for the specified columns. This is different from
+     * [allColsExcept][org.jetbrains.kotlinx.dataframe.api.AllExceptColumnsSelectionDsl.allColsExcept] in that it does not 'lift' the columns out of the group, but instead selects the group itself.
+     *
+     * As usual, all overloads for each [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi] are available.
+     *
+     * These produce the same result:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`(colGroup) `[except][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.except]` colGroup.col }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  { colGroup  `[exceptNew][SingleColumn.except]` { col } }`
+     *
+     * These functions are experimental and may be removed or changed in the future.
+     *
+     * Trying these functions requires you to `@`[`OptIn`][OptIn]`(`[ExperimentalExceptCsDsl][org.jetbrains.kotlinx.dataframe.api.ExperimentalExceptCsDsl]`::class)` first.
+     *
+     * ## NOTE:
+     * `exceptNew` will likely be renamed to `except` when the deprecated [SingleColumn.except] functions
+     * are deleted.
+     */
+    @ExperimentalExceptCsDsl
+    @Suppress("INAPPLICABLE_JVM_NAME")
+    @JvmName("KPropertyDataRowExceptNew")
+    public infix fun <C> KProperty<DataRow<C>>.exceptNew(other: KProperty<*>): SingleColumn<DataRow<C>> =
+        columnGroup(this).exceptExperimentalInternal(column(other))
+
+    /**
+     * ## EXPERIMENTAL: Except on Column Group
+     *
+     * Selects the current column group itself, except for the specified columns. This is different from
+     * [allColsExcept][org.jetbrains.kotlinx.dataframe.api.AllExceptColumnsSelectionDsl.allColsExcept] in that it does not 'lift' the columns out of the group, but instead selects the group itself.
+     *
+     * As usual, all overloads for each [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi] are available.
+     *
+     * These produce the same result:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`(colGroup) `[except][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.except]` colGroup.col }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  { colGroup  `[exceptNew][SingleColumn.except]` { col } }`
+     *
+     * These functions are experimental and may be removed or changed in the future.
+     *
+     * Trying these functions requires you to `@`[`OptIn`][OptIn]`(`[ExperimentalExceptCsDsl][org.jetbrains.kotlinx.dataframe.api.ExperimentalExceptCsDsl]`::class)` first.
+     *
+     * ## NOTE:
+     * `exceptNew` will likely be renamed to `except` when the deprecated [SingleColumn.except] functions
+     * are deleted.
+     */
+    @ExperimentalExceptCsDsl
+    @Suppress("INAPPLICABLE_JVM_NAME")
+    @JvmName("KPropertyDataRowExceptNew")
+    public fun <C> KProperty<DataRow<C>>.exceptNew(vararg others: KProperty<*>): SingleColumn<DataRow<C>> =
+        columnGroup(this).exceptExperimentalInternal(others.toColumnSet())
+
+    /**
+     * ## EXPERIMENTAL: Except on Column Group
+     *
+     * Selects the current column group itself, except for the specified columns. This is different from
+     * [allColsExcept][org.jetbrains.kotlinx.dataframe.api.AllExceptColumnsSelectionDsl.allColsExcept] in that it does not 'lift' the columns out of the group, but instead selects the group itself.
+     *
+     * As usual, all overloads for each [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi] are available.
+     *
+     * These produce the same result:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`(colGroup) `[except][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.except]` colGroup.col }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  { colGroup  `[exceptNew][SingleColumn.except]` { col } }`
+     *
+     * These functions are experimental and may be removed or changed in the future.
+     *
+     * Trying these functions requires you to `@`[`OptIn`][OptIn]`(`[ExperimentalExceptCsDsl][org.jetbrains.kotlinx.dataframe.api.ExperimentalExceptCsDsl]`::class)` first.
+     *
+     * ## NOTE:
+     * `exceptNew` will likely be renamed to `except` when the deprecated [SingleColumn.except] functions
+     * are deleted.
+     */
+    @ExperimentalExceptCsDsl
+    public infix fun <C> KProperty<C>.exceptNew(other: ColumnPath): SingleColumn<DataRow<C>> =
+        columnGroup(this).exceptExperimentalInternal(column<Any?>(other))
+
+    /**
+     * ## EXPERIMENTAL: Except on Column Group
+     *
+     * Selects the current column group itself, except for the specified columns. This is different from
+     * [allColsExcept][org.jetbrains.kotlinx.dataframe.api.AllExceptColumnsSelectionDsl.allColsExcept] in that it does not 'lift' the columns out of the group, but instead selects the group itself.
+     *
+     * As usual, all overloads for each [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi] are available.
+     *
+     * These produce the same result:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`(colGroup) `[except][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.except]` colGroup.col }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  { colGroup  `[exceptNew][SingleColumn.except]` { col } }`
+     *
+     * These functions are experimental and may be removed or changed in the future.
+     *
+     * Trying these functions requires you to `@`[`OptIn`][OptIn]`(`[ExperimentalExceptCsDsl][org.jetbrains.kotlinx.dataframe.api.ExperimentalExceptCsDsl]`::class)` first.
+     *
+     * ## NOTE:
+     * `exceptNew` will likely be renamed to `except` when the deprecated [SingleColumn.except] functions
+     * are deleted.
+     */
+    @ExperimentalExceptCsDsl
+    public fun <C> KProperty<C>.exceptNew(vararg others: ColumnPath): SingleColumn<DataRow<C>> =
+        columnGroup(this).exceptExperimentalInternal(others.toColumnSet())
+
+    /**
+     * ## EXPERIMENTAL: Except on Column Group
+     *
+     * Selects the current column group itself, except for the specified columns. This is different from
+     * [allColsExcept][org.jetbrains.kotlinx.dataframe.api.AllExceptColumnsSelectionDsl.allColsExcept] in that it does not 'lift' the columns out of the group, but instead selects the group itself.
+     *
+     * As usual, all overloads for each [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi] are available.
+     *
+     * These produce the same result:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`(colGroup) `[except][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.except]` colGroup.col }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  { colGroup  `[exceptNew][SingleColumn.except]` { col } }`
+     *
+     * These functions are experimental and may be removed or changed in the future.
+     *
+     * Trying these functions requires you to `@`[`OptIn`][OptIn]`(`[ExperimentalExceptCsDsl][org.jetbrains.kotlinx.dataframe.api.ExperimentalExceptCsDsl]`::class)` first.
+     *
+     * ## NOTE:
+     * `exceptNew` will likely be renamed to `except` when the deprecated [SingleColumn.except] functions
+     * are deleted.
+     */
+    @ExperimentalExceptCsDsl
+    @Suppress("INAPPLICABLE_JVM_NAME")
+    @JvmName("KPropertyDataRowExceptNew")
+    public infix fun <C> KProperty<DataRow<C>>.exceptNew(other: ColumnPath): SingleColumn<DataRow<C>> =
+        columnGroup(this).exceptExperimentalInternal(column<Any?>(other))
+
+    /**
+     * ## EXPERIMENTAL: Except on Column Group
+     *
+     * Selects the current column group itself, except for the specified columns. This is different from
+     * [allColsExcept][org.jetbrains.kotlinx.dataframe.api.AllExceptColumnsSelectionDsl.allColsExcept] in that it does not 'lift' the columns out of the group, but instead selects the group itself.
+     *
+     * As usual, all overloads for each [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi] are available.
+     *
+     * These produce the same result:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`(colGroup) `[except][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.except]` colGroup.col }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  { colGroup  `[exceptNew][SingleColumn.except]` { col } }`
+     *
+     * These functions are experimental and may be removed or changed in the future.
+     *
+     * Trying these functions requires you to `@`[`OptIn`][OptIn]`(`[ExperimentalExceptCsDsl][org.jetbrains.kotlinx.dataframe.api.ExperimentalExceptCsDsl]`::class)` first.
+     *
+     * ## NOTE:
+     * `exceptNew` will likely be renamed to `except` when the deprecated [SingleColumn.except] functions
+     * are deleted.
+     */
+    @ExperimentalExceptCsDsl
+    @Suppress("INAPPLICABLE_JVM_NAME")
+    @JvmName("KPropertyDataRowExceptNew")
+    public fun <C> KProperty<DataRow<C>>.exceptNew(vararg others: ColumnPath): SingleColumn<DataRow<C>> =
+        columnGroup(this).exceptExperimentalInternal(others.toColumnSet())
+
+    /**
+     * ## EXPERIMENTAL: Except on Column Group
+     *
+     * Selects the current column group itself, except for the specified columns. This is different from
+     * [allColsExcept][org.jetbrains.kotlinx.dataframe.api.AllExceptColumnsSelectionDsl.allColsExcept] in that it does not 'lift' the columns out of the group, but instead selects the group itself.
+     *
+     * As usual, all overloads for each [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi] are available.
+     *
+     * These produce the same result:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`(colGroup) `[except][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.except]` colGroup.col }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  { colGroup  `[exceptNew][SingleColumn.except]` { col } }`
+     *
+     * These functions are experimental and may be removed or changed in the future.
+     *
+     * Trying these functions requires you to `@`[`OptIn`][OptIn]`(`[ExperimentalExceptCsDsl][org.jetbrains.kotlinx.dataframe.api.ExperimentalExceptCsDsl]`::class)` first.
+     *
+     * ## NOTE:
+     * `exceptNew` will likely be renamed to `except` when the deprecated [SingleColumn.except] functions
+     * are deleted.
+     */
+    @ExperimentalExceptCsDsl
+    public infix fun ColumnPath.exceptNew(selector: ColumnsSelector<*, *>): SingleColumn<DataRow<*>> =
+        columnGroup(this).exceptExperimentalInternal(selector.toColumns<Any?, Any?>())
+
+    @ExperimentalExceptCsDsl
+    @Deprecated(
+        message = ALL_COLS_EXCEPT,
+        replaceWith = ReplaceWith("exceptNew { other }"),
+        level = DeprecationLevel.ERROR,
+    ) // present solely to redirect users to the right function
+    public infix fun ColumnPath.exceptNew(other: ColumnsResolver<*>): SingleColumn<DataRow<*>> =
+        exceptNew { other }
+
+    @ExperimentalExceptCsDsl
+    @Deprecated(
+        message = ALL_COLS_EXCEPT,
+        replaceWith = ReplaceWith("exceptNew { others.toColumnSet() }"),
+        level = DeprecationLevel.ERROR,
+    ) // present solely to redirect users to the right function
+    public fun ColumnPath.exceptNew(vararg others: ColumnsResolver<*>): SingleColumn<DataRow<*>> =
+        exceptNew { others.toColumnSet() }
+
+    /**
+     * ## EXPERIMENTAL: Except on Column Group
+     *
+     * Selects the current column group itself, except for the specified columns. This is different from
+     * [allColsExcept][org.jetbrains.kotlinx.dataframe.api.AllExceptColumnsSelectionDsl.allColsExcept] in that it does not 'lift' the columns out of the group, but instead selects the group itself.
+     *
+     * As usual, all overloads for each [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi] are available.
+     *
+     * These produce the same result:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`(colGroup) `[except][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.except]` colGroup.col }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  { colGroup  `[exceptNew][SingleColumn.except]` { col } }`
+     *
+     * These functions are experimental and may be removed or changed in the future.
+     *
+     * Trying these functions requires you to `@`[`OptIn`][OptIn]`(`[ExperimentalExceptCsDsl][org.jetbrains.kotlinx.dataframe.api.ExperimentalExceptCsDsl]`::class)` first.
+     *
+     * ## NOTE:
+     * `exceptNew` will likely be renamed to `except` when the deprecated [SingleColumn.except] functions
+     * are deleted.
+     */
+    @ExperimentalExceptCsDsl
+    public infix fun ColumnPath.exceptNew(other: String): SingleColumn<DataRow<*>> =
+        columnGroup(this).exceptExperimentalInternal(column<Any?>(other))
+
+    /**
+     * ## EXPERIMENTAL: Except on Column Group
+     *
+     * Selects the current column group itself, except for the specified columns. This is different from
+     * [allColsExcept][org.jetbrains.kotlinx.dataframe.api.AllExceptColumnsSelectionDsl.allColsExcept] in that it does not 'lift' the columns out of the group, but instead selects the group itself.
+     *
+     * As usual, all overloads for each [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi] are available.
+     *
+     * These produce the same result:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`(colGroup) `[except][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.except]` colGroup.col }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  { colGroup  `[exceptNew][SingleColumn.except]` { col } }`
+     *
+     * These functions are experimental and may be removed or changed in the future.
+     *
+     * Trying these functions requires you to `@`[`OptIn`][OptIn]`(`[ExperimentalExceptCsDsl][org.jetbrains.kotlinx.dataframe.api.ExperimentalExceptCsDsl]`::class)` first.
+     *
+     * ## NOTE:
+     * `exceptNew` will likely be renamed to `except` when the deprecated [SingleColumn.except] functions
+     * are deleted.
+     */
+    @ExperimentalExceptCsDsl
+    public fun ColumnPath.exceptNew(vararg others: String): SingleColumn<DataRow<*>> =
+        columnGroup(this).exceptExperimentalInternal(others.toColumnSet())
+
+    /**
+     * ## EXPERIMENTAL: Except on Column Group
+     *
+     * Selects the current column group itself, except for the specified columns. This is different from
+     * [allColsExcept][org.jetbrains.kotlinx.dataframe.api.AllExceptColumnsSelectionDsl.allColsExcept] in that it does not 'lift' the columns out of the group, but instead selects the group itself.
+     *
+     * As usual, all overloads for each [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi] are available.
+     *
+     * These produce the same result:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`(colGroup) `[except][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.except]` colGroup.col }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  { colGroup  `[exceptNew][SingleColumn.except]` { col } }`
+     *
+     * These functions are experimental and may be removed or changed in the future.
+     *
+     * Trying these functions requires you to `@`[`OptIn`][OptIn]`(`[ExperimentalExceptCsDsl][org.jetbrains.kotlinx.dataframe.api.ExperimentalExceptCsDsl]`::class)` first.
+     *
+     * ## NOTE:
+     * `exceptNew` will likely be renamed to `except` when the deprecated [SingleColumn.except] functions
+     * are deleted.
+     */
+    @ExperimentalExceptCsDsl
+    public infix fun ColumnPath.exceptNew(other: KProperty<*>): SingleColumn<DataRow<*>> =
+        columnGroup(this).exceptExperimentalInternal(column(other))
+
+    @ExperimentalExceptCsDsl
+    public fun ColumnPath.exceptNew(vararg others: KProperty<*>): SingleColumn<DataRow<*>> =
+        columnGroup(this).exceptExperimentalInternal(others.toColumnSet())
+
+    /**
+     * ## EXPERIMENTAL: Except on Column Group
+     *
+     * Selects the current column group itself, except for the specified columns. This is different from
+     * [allColsExcept][org.jetbrains.kotlinx.dataframe.api.AllExceptColumnsSelectionDsl.allColsExcept] in that it does not 'lift' the columns out of the group, but instead selects the group itself.
+     *
+     * As usual, all overloads for each [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi] are available.
+     *
+     * These produce the same result:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`(colGroup) `[except][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.except]` colGroup.col }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  { colGroup  `[exceptNew][SingleColumn.except]` { col } }`
+     *
+     * These functions are experimental and may be removed or changed in the future.
+     *
+     * Trying these functions requires you to `@`[`OptIn`][OptIn]`(`[ExperimentalExceptCsDsl][org.jetbrains.kotlinx.dataframe.api.ExperimentalExceptCsDsl]`::class)` first.
+     *
+     * ## NOTE:
+     * `exceptNew` will likely be renamed to `except` when the deprecated [SingleColumn.except] functions
+     * are deleted.
+     */
+    @ExperimentalExceptCsDsl
+    public infix fun ColumnPath.exceptNew(other: ColumnPath): SingleColumn<DataRow<*>> =
+        columnGroup(this).exceptExperimentalInternal(column<Any?>(other))
+
+    /**
+     * ## EXPERIMENTAL: Except on Column Group
+     *
+     * Selects the current column group itself, except for the specified columns. This is different from
+     * [allColsExcept][org.jetbrains.kotlinx.dataframe.api.AllExceptColumnsSelectionDsl.allColsExcept] in that it does not 'lift' the columns out of the group, but instead selects the group itself.
+     *
+     * As usual, all overloads for each [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi] are available.
+     *
+     * These produce the same result:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`(colGroup) `[except][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.except]` colGroup.col }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  { colGroup  `[exceptNew][SingleColumn.except]` { col } }`
+     *
+     * These functions are experimental and may be removed or changed in the future.
+     *
+     * Trying these functions requires you to `@`[`OptIn`][OptIn]`(`[ExperimentalExceptCsDsl][org.jetbrains.kotlinx.dataframe.api.ExperimentalExceptCsDsl]`::class)` first.
+     *
+     * ## NOTE:
+     * `exceptNew` will likely be renamed to `except` when the deprecated [SingleColumn.except] functions
+     * are deleted.
+     */
+    @ExperimentalExceptCsDsl
+    public fun ColumnPath.exceptNew(vararg others: ColumnPath): SingleColumn<DataRow<*>> =
+        columnGroup(this).exceptExperimentalInternal(others.toColumnSet())
+
+    // endregion
+}
+
+/**
+ * Removes the columns in the "other" ColumnsResolver from the current ColumnSet while keeping the structure intact.
+ * Returns a new ColumnSet with the remaining columns.
+ *
+ * @param other The ColumnsResolver containing the columns to be removed.
+ * @return The new ColumnSet with the remaining columns.
+ */
+@Suppress("UNCHECKED_CAST")
+internal fun <C> ColumnSet<C>.exceptInternal(other: ColumnsResolver<*>): ColumnSet<C> =
+    createColumnSet { context ->
+        val resolvedCols = this.resolve(context)
+        val resolvedColsToExcept = other.resolve(context)
+        resolvedCols.allColumnsExceptKeepingStructure(resolvedColsToExcept)
+    } as ColumnSet<C>
+
+/**
+ * Returns a new ColumnSet that contains all columns from inside the receiver column group
+ * except those specified in the "other" ColumnsResolver.
+ *
+ * @param other The ColumnsResolver containing the columns to be removed.
+ * @return The new ColumnSet with the remaining columns.
+ */
+internal fun SingleColumn<DataRow<*>>.allColsExceptInternal(other: ColumnsResolver<*>): ColumnSet<Any?> =
+    selectInternal { all().exceptInternal(other) }
+
+/**
+ * Returns a new SingleColumn<DataRow<C>> that has the same structure as the receiver, but excludes columns
+ * specified in the "other" ColumnsResolver.
+ *
+ * @param other The [ColumnsResolver] to use for excluding columns.
+ * @return A new [SingleColumn] with the filtered columns excluded.
+ */
+@Suppress("UNCHECKED_CAST")
+internal fun <C> SingleColumn<DataRow<C>>.exceptExperimentalInternal(
+    other: ColumnsResolver<*>,
+): SingleColumn<DataRow<C>> =
+    ensureIsColumnGroup().transformSingle { singleCol ->
+        val columnsToExcept = singleCol
+            .asColumnGroup()
+            .getColumnsWithPaths { other }
+            .map { it.changePath(singleCol.path + it.path) }
+
+        val newCols = listOf(singleCol).allColumnsExceptKeepingStructure(columnsToExcept)
+
+        newCols as List<ColumnWithPath<DataRow<*>>>
+    }.singleInternal() as SingleColumn<DataRow<C>>
+
+/**
+ * Functions annotated with this annotation are experimental and will be removed or renamed in the future.
+ */
+@RequiresOptIn(level = RequiresOptIn.Level.ERROR)
+@Target(AnnotationTarget.FUNCTION)
+public annotation class ExperimentalExceptCsDsl
+
+// endregion
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/and.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/and.kt
new file mode 100644
index 000000000..2bd106c4b
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/and.kt
@@ -0,0 +1,647 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import org.jetbrains.kotlinx.dataframe.DataColumn
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.annotations.Interpretable
+import org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.Grammar
+import org.jetbrains.kotlinx.dataframe.columns.ColumnPath
+import org.jetbrains.kotlinx.dataframe.columns.ColumnReference
+import org.jetbrains.kotlinx.dataframe.columns.ColumnSet
+import org.jetbrains.kotlinx.dataframe.columns.ColumnsResolver
+import org.jetbrains.kotlinx.dataframe.columns.SingleColumn
+import org.jetbrains.kotlinx.dataframe.impl.columns.ColumnsList
+import kotlin.reflect.KProperty
+
+// region ColumnsSelectionDsl
+
+/**
+ * ## And [Columns Selection DSL][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl]
+ *
+ * See [Grammar] for all functions in this interface.
+ */
+public interface AndColumnsSelectionDsl {
+
+    /**
+     * ## And Operator Grammar
+     *
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * [(What is this notation?)][org.jetbrains.kotlinx.dataframe.documentation.DslGrammar]
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  ### Definitions:
+     *  `columnSet: `[`ColumnSet`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]`<*>`
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  `columnGroup: `[`SingleColumn`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]`<`[`DataRow`][org.jetbrains.kotlinx.dataframe.DataRow]`<*>> | `[`String`][String]`  |  `[`KProperty`][kotlin.reflect.KProperty]`<* | `[`DataRow`][org.jetbrains.kotlinx.dataframe.DataRow]`<*>> | `[`ColumnPath`][org.jetbrains.kotlinx.dataframe.columns.ColumnPath]
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  `column: `[`ColumnAccessor`][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor]`  |  `[`String`][String]`  | `[`KProperty`][kotlin.reflect.KProperty]`<*> | `[`ColumnPath`][org.jetbrains.kotlinx.dataframe.columns.ColumnPath]
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  `columnOrSet: `[`column`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ColumnDef]`  |  `[`columnSet`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ColumnSetDef]
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  ### What can be called directly in the [Columns Selection DSL][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl]:
+     *
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  [`columnOrSet`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ColumnOrColumnSetDef]` `[**`and`**][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]`  [  `**`{`**`  ]  `[`columnOrSet`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ColumnOrColumnSetDef]`  [  `**`}`**` ]`
+     *
+     *  `| `[`columnOrSet`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ColumnOrColumnSetDef]__`.`__[**`and`**][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]**` (`**`|`**`{ `**[`columnOrSet`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ColumnOrColumnSetDef]**` }`**`|`**`)`**
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  ### What can be called on a [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]:
+     *
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  [`columnSet`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ColumnSetDef]
+     *
+     *  &nbsp;&nbsp;&nbsp;&nbsp;__`.`__[**`and`**][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]**` (`**`|`**`{ `**[`columnOrSet`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ColumnOrColumnSetDef]**` }`**`|`**`)`**
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  ### What can be called on a [Column Group (reference)][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ColumnGroupDef]:
+     *
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  [`columnGroup`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ColumnGroupDef]
+     *
+     *  &nbsp;&nbsp;&nbsp;&nbsp;__`.`__[**`and`**][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]**` (`**`|`**`{ `**[`columnOrSet`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ColumnOrColumnSetDef]**` }`**`|`**`)`**
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     */
+    public interface Grammar {
+
+        /** [**`and`**][ColumnsSelectionDsl.and] */
+        public interface InfixName
+
+        /** __`.`__[**`and`**][ColumnsSelectionDsl.and] */
+        public interface Name
+    }
+
+    /**
+     * ## And Operator
+     * The [and] operator allows you to combine selections of columns or simply select multiple columns at once.
+     *
+     * You can even mix and match any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]!
+     *
+     * ### Check out: [Grammar]
+     *
+     * #### Examples:
+     *
+     * `df.`[`groupBy`][DataFrame.groupBy]`  { "colA"  `[`and`][String.and]` colB }`
+     *
+     * `df.`[`select`][DataFrame.select]` {`
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;[`colsOf`][SingleColumn.colsOf]`<`[`String`][String]`>() `[`and`][ColumnSet.and]` {`
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;[`colsAtAnyDepth`][ColumnsSelectionDsl.colsAtAnyDepth]`  { "price"  `[`in`][String.contains]` it.`[`name`][DataColumn.name]` }`
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;`}`
+     *
+     * `}`
+     *
+     * `df.`[`select`][DataFrame.select]`  { "colC"  `[`and`][String.and]`  Type::colB  `[`and`][KProperty.and]`  "pathTo"["colC"]  `[`and`][ColumnPath.and]` colD }`
+     *
+     * #### Example for this overload:
+     *
+     *
+     *
+     * @return A [ColumnSet] that contains all the columns from the [ColumnsResolvers][ColumnsResolver] on the left
+     *   and right side of the [and] operator.
+     */
+    private interface CommonAndDocs {
+
+        interface ExampleArg
+    }
+
+    // region ColumnsResolver
+
+    /**
+     * ## And Operator
+     * The [and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and] operator allows you to combine selections of columns or simply select multiple columns at once.
+     *
+     * You can even mix and match any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]!
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.Grammar]
+     *
+     * #### Examples:
+     *
+     * `df.`[`groupBy`][org.jetbrains.kotlinx.dataframe.DataFrame.groupBy]`  { "colA"  `[`and`][kotlin.String.and]` colB }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` {`
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;[`colsOf`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.colsOf]`<`[`String`][String]`>() `[`and`][org.jetbrains.kotlinx.dataframe.columns.ColumnsResolver.and]` {`
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;[`colsAtAnyDepth`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsAtAnyDepth]`  { "price"  `[`in`][String.contains]` it.`[`name`][org.jetbrains.kotlinx.dataframe.DataColumn.name]` }`
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;`}`
+     *
+     * `}`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  { "colC"  `[`and`][kotlin.String.and]`  Type::colB  `[`and`][kotlin.reflect.KProperty.and]`  "pathTo"["colC"]  `[`and`][org.jetbrains.kotlinx.dataframe.columns.ColumnsResolver.and]` colD }`
+     *
+     * #### Example for this overload:
+     *
+     * `df.`[select][DataFrame.select]`  {  `[`cols`][ColumnsSelectionDsl.cols]`  { ... }  `[`and`][ColumnsResolver.and]` `<code></code>` }`
+     *
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] that contains all the columns from the [ColumnsResolvers][org.jetbrains.kotlinx.dataframe.columns.ColumnsResolver] on the left
+     *   and right side of the [and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and] operator.
+     */
+    private interface ColumnsResolverAndDocs {
+
+        interface Argument
+    }
+
+    /** ## And Operator
+     * The [and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and] operator allows you to combine selections of columns or simply select multiple columns at once.
+     *
+     * You can even mix and match any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]!
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.Grammar]
+     *
+     * #### Examples:
+     *
+     * `df.`[`groupBy`][org.jetbrains.kotlinx.dataframe.DataFrame.groupBy]`  { "colA"  `[`and`][kotlin.String.and]` colB }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` {`
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;[`colsOf`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.colsOf]`<`[`String`][String]`>() `[`and`][org.jetbrains.kotlinx.dataframe.columns.ColumnsResolver.and]` {`
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;[`colsAtAnyDepth`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsAtAnyDepth]`  { "price"  `[`in`][String.contains]` it.`[`name`][org.jetbrains.kotlinx.dataframe.DataColumn.name]` }`
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;`}`
+     *
+     * `}`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  { "colC"  `[`and`][kotlin.String.and]`  Type::colB  `[`and`][kotlin.reflect.KProperty.and]`  "pathTo"["colC"]  `[`and`][org.jetbrains.kotlinx.dataframe.columns.ColumnsResolver.and]` colD }`
+     *
+     * #### Example for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[`cols`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`  { ... }  `[`and`][org.jetbrains.kotlinx.dataframe.columns.ColumnsResolver.and]` `<code>[`colsOf`][SingleColumn.colsOf]`<`[`Int`][Int]`>()`</code>` }`
+     *
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] that contains all the columns from the [ColumnsResolvers][org.jetbrains.kotlinx.dataframe.columns.ColumnsResolver] on the left
+     *   and right side of the [and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and] operator.
+     */
+    @Interpretable("And0")
+    public infix fun <C> ColumnsResolver<C>.and(other: ColumnsResolver<C>): ColumnSet<C> = ColumnsList(this, other)
+
+    /** ## And Operator
+     * The [and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and] operator allows you to combine selections of columns or simply select multiple columns at once.
+     *
+     * You can even mix and match any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]!
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.Grammar]
+     *
+     * #### Examples:
+     *
+     * `df.`[`groupBy`][org.jetbrains.kotlinx.dataframe.DataFrame.groupBy]`  { "colA"  `[`and`][kotlin.String.and]` colB }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` {`
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;[`colsOf`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.colsOf]`<`[`String`][String]`>() `[`and`][org.jetbrains.kotlinx.dataframe.columns.ColumnsResolver.and]` {`
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;[`colsAtAnyDepth`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsAtAnyDepth]`  { "price"  `[`in`][String.contains]` it.`[`name`][org.jetbrains.kotlinx.dataframe.DataColumn.name]` }`
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;`}`
+     *
+     * `}`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  { "colC"  `[`and`][kotlin.String.and]`  Type::colB  `[`and`][kotlin.reflect.KProperty.and]`  "pathTo"["colC"]  `[`and`][org.jetbrains.kotlinx.dataframe.columns.ColumnsResolver.and]` colD }`
+     *
+     * #### Example for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[`cols`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`  { ... }  `[`and`][org.jetbrains.kotlinx.dataframe.columns.ColumnsResolver.and]` `<code>`{ colA `[`/`][DataColumn.div]`  2.0  `[`named`][ColumnReference.named]` "half colA" }`</code>` }`
+     *
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] that contains all the columns from the [ColumnsResolvers][org.jetbrains.kotlinx.dataframe.columns.ColumnsResolver] on the left
+     *   and right side of the [and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and] operator.
+     */
+    public infix fun <C> ColumnsResolver<C>.and(other: () -> ColumnsResolver<C>): ColumnSet<C> = this and other()
+
+    /** ## And Operator
+     * The [and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and] operator allows you to combine selections of columns or simply select multiple columns at once.
+     *
+     * You can even mix and match any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]!
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.Grammar]
+     *
+     * #### Examples:
+     *
+     * `df.`[`groupBy`][org.jetbrains.kotlinx.dataframe.DataFrame.groupBy]`  { "colA"  `[`and`][kotlin.String.and]` colB }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` {`
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;[`colsOf`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.colsOf]`<`[`String`][String]`>() `[`and`][org.jetbrains.kotlinx.dataframe.columns.ColumnsResolver.and]` {`
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;[`colsAtAnyDepth`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsAtAnyDepth]`  { "price"  `[`in`][String.contains]` it.`[`name`][org.jetbrains.kotlinx.dataframe.DataColumn.name]` }`
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;`}`
+     *
+     * `}`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  { "colC"  `[`and`][kotlin.String.and]`  Type::colB  `[`and`][kotlin.reflect.KProperty.and]`  "pathTo"["colC"]  `[`and`][org.jetbrains.kotlinx.dataframe.columns.ColumnsResolver.and]` colD }`
+     *
+     * #### Example for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[`cols`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`  { ... }  `[`and`][org.jetbrains.kotlinx.dataframe.columns.ColumnsResolver.and]` `<code>`"colB"`</code>` }`
+     *
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] that contains all the columns from the [ColumnsResolvers][org.jetbrains.kotlinx.dataframe.columns.ColumnsResolver] on the left
+     *   and right side of the [and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and] operator.
+     */
+    public infix fun <C> ColumnsResolver<C>.and(other: String): ColumnSet<*> = this and other.toColumnAccessor()
+
+    /** ## And Operator
+     * The [and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and] operator allows you to combine selections of columns or simply select multiple columns at once.
+     *
+     * You can even mix and match any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]!
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.Grammar]
+     *
+     * #### Examples:
+     *
+     * `df.`[`groupBy`][org.jetbrains.kotlinx.dataframe.DataFrame.groupBy]`  { "colA"  `[`and`][kotlin.String.and]` colB }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` {`
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;[`colsOf`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.colsOf]`<`[`String`][String]`>() `[`and`][org.jetbrains.kotlinx.dataframe.columns.ColumnsResolver.and]` {`
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;[`colsAtAnyDepth`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsAtAnyDepth]`  { "price"  `[`in`][String.contains]` it.`[`name`][org.jetbrains.kotlinx.dataframe.DataColumn.name]` }`
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;`}`
+     *
+     * `}`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  { "colC"  `[`and`][kotlin.String.and]`  Type::colB  `[`and`][kotlin.reflect.KProperty.and]`  "pathTo"["colC"]  `[`and`][org.jetbrains.kotlinx.dataframe.columns.ColumnsResolver.and]` colD }`
+     *
+     * #### Example for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[`cols`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`  { ... }  `[`and`][org.jetbrains.kotlinx.dataframe.columns.ColumnsResolver.and]` `<code>`Type::colB`</code>` }`
+     *
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] that contains all the columns from the [ColumnsResolvers][org.jetbrains.kotlinx.dataframe.columns.ColumnsResolver] on the left
+     *   and right side of the [and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and] operator.
+     */
+    public infix fun <C> ColumnsResolver<C>.and(other: KProperty<C>): ColumnSet<C> = this and other.toColumnAccessor()
+
+    // endregion
+
+    // region String
+
+    /**
+     * ## And Operator
+     * The [and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and] operator allows you to combine selections of columns or simply select multiple columns at once.
+     *
+     * You can even mix and match any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]!
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.Grammar]
+     *
+     * #### Examples:
+     *
+     * `df.`[`groupBy`][org.jetbrains.kotlinx.dataframe.DataFrame.groupBy]`  { "colA"  `[`and`][kotlin.String.and]` colB }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` {`
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;[`colsOf`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.colsOf]`<`[`String`][String]`>() `[`and`][org.jetbrains.kotlinx.dataframe.columns.ColumnsResolver.and]` {`
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;[`colsAtAnyDepth`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsAtAnyDepth]`  { "price"  `[`in`][String.contains]` it.`[`name`][org.jetbrains.kotlinx.dataframe.DataColumn.name]` }`
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;`}`
+     *
+     * `}`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  { "colC"  `[`and`][kotlin.String.and]`  Type::colB  `[`and`][kotlin.reflect.KProperty.and]`  "pathTo"["colC"]  `[`and`][org.jetbrains.kotlinx.dataframe.columns.ColumnsResolver.and]` colD }`
+     *
+     * #### Example for this overload:
+     *
+     * `df.`[select][DataFrame.select]`  { "colA"  `[`and`][String.and]` `<code></code>` }`
+     *
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] that contains all the columns from the [ColumnsResolvers][org.jetbrains.kotlinx.dataframe.columns.ColumnsResolver] on the left
+     *   and right side of the [and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and] operator.
+     */
+    private interface StringAndDocs {
+
+        interface Argument
+    }
+
+    /** ## And Operator
+     * The [and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and] operator allows you to combine selections of columns or simply select multiple columns at once.
+     *
+     * You can even mix and match any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]!
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.Grammar]
+     *
+     * #### Examples:
+     *
+     * `df.`[`groupBy`][org.jetbrains.kotlinx.dataframe.DataFrame.groupBy]`  { "colA"  `[`and`][kotlin.String.and]` colB }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` {`
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;[`colsOf`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.colsOf]`<`[`String`][String]`>() `[`and`][org.jetbrains.kotlinx.dataframe.columns.ColumnsResolver.and]` {`
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;[`colsAtAnyDepth`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsAtAnyDepth]`  { "price"  `[`in`][String.contains]` it.`[`name`][org.jetbrains.kotlinx.dataframe.DataColumn.name]` }`
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;`}`
+     *
+     * `}`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  { "colC"  `[`and`][kotlin.String.and]`  Type::colB  `[`and`][kotlin.reflect.KProperty.and]`  "pathTo"["colC"]  `[`and`][org.jetbrains.kotlinx.dataframe.columns.ColumnsResolver.and]` colD }`
+     *
+     * #### Example for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  { "colA"  `[`and`][kotlin.String.and]` `<code>[`colsOf`][SingleColumn.colsOf]`<`[`Int`][Int]`>()`</code>` }`
+     *
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] that contains all the columns from the [ColumnsResolvers][org.jetbrains.kotlinx.dataframe.columns.ColumnsResolver] on the left
+     *   and right side of the [and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and] operator.
+     */
+    public infix fun <C> String.and(other: ColumnsResolver<C>): ColumnSet<*> = toColumnAccessor() and other
+
+    /** ## And Operator
+     * The [and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and] operator allows you to combine selections of columns or simply select multiple columns at once.
+     *
+     * You can even mix and match any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]!
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.Grammar]
+     *
+     * #### Examples:
+     *
+     * `df.`[`groupBy`][org.jetbrains.kotlinx.dataframe.DataFrame.groupBy]`  { "colA"  `[`and`][kotlin.String.and]` colB }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` {`
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;[`colsOf`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.colsOf]`<`[`String`][String]`>() `[`and`][org.jetbrains.kotlinx.dataframe.columns.ColumnsResolver.and]` {`
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;[`colsAtAnyDepth`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsAtAnyDepth]`  { "price"  `[`in`][String.contains]` it.`[`name`][org.jetbrains.kotlinx.dataframe.DataColumn.name]` }`
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;`}`
+     *
+     * `}`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  { "colC"  `[`and`][kotlin.String.and]`  Type::colB  `[`and`][kotlin.reflect.KProperty.and]`  "pathTo"["colC"]  `[`and`][org.jetbrains.kotlinx.dataframe.columns.ColumnsResolver.and]` colD }`
+     *
+     * #### Example for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  { "colA"  `[`and`][kotlin.String.and]` `<code>`{ colA `[`/`][DataColumn.div]`  2.0  `[`named`][ColumnReference.named]` "half colA" }`</code>` }`
+     *
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] that contains all the columns from the [ColumnsResolvers][org.jetbrains.kotlinx.dataframe.columns.ColumnsResolver] on the left
+     *   and right side of the [and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and] operator.
+     */
+    public infix fun <C> String.and(other: () -> ColumnsResolver<C>): ColumnSet<*> = toColumnAccessor() and other()
+
+    /** ## And Operator
+     * The [and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and] operator allows you to combine selections of columns or simply select multiple columns at once.
+     *
+     * You can even mix and match any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]!
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.Grammar]
+     *
+     * #### Examples:
+     *
+     * `df.`[`groupBy`][org.jetbrains.kotlinx.dataframe.DataFrame.groupBy]`  { "colA"  `[`and`][kotlin.String.and]` colB }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` {`
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;[`colsOf`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.colsOf]`<`[`String`][String]`>() `[`and`][org.jetbrains.kotlinx.dataframe.columns.ColumnsResolver.and]` {`
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;[`colsAtAnyDepth`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsAtAnyDepth]`  { "price"  `[`in`][String.contains]` it.`[`name`][org.jetbrains.kotlinx.dataframe.DataColumn.name]` }`
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;`}`
+     *
+     * `}`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  { "colC"  `[`and`][kotlin.String.and]`  Type::colB  `[`and`][kotlin.reflect.KProperty.and]`  "pathTo"["colC"]  `[`and`][org.jetbrains.kotlinx.dataframe.columns.ColumnsResolver.and]` colD }`
+     *
+     * #### Example for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  { "colA"  `[`and`][kotlin.String.and]` `<code>`"colB"`</code>` }`
+     *
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] that contains all the columns from the [ColumnsResolvers][org.jetbrains.kotlinx.dataframe.columns.ColumnsResolver] on the left
+     *   and right side of the [and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and] operator.
+     */
+    public infix fun String.and(other: String): ColumnSet<*> = toColumnAccessor() and other.toColumnAccessor()
+
+    /** ## And Operator
+     * The [and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and] operator allows you to combine selections of columns or simply select multiple columns at once.
+     *
+     * You can even mix and match any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]!
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.Grammar]
+     *
+     * #### Examples:
+     *
+     * `df.`[`groupBy`][org.jetbrains.kotlinx.dataframe.DataFrame.groupBy]`  { "colA"  `[`and`][kotlin.String.and]` colB }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` {`
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;[`colsOf`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.colsOf]`<`[`String`][String]`>() `[`and`][org.jetbrains.kotlinx.dataframe.columns.ColumnsResolver.and]` {`
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;[`colsAtAnyDepth`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsAtAnyDepth]`  { "price"  `[`in`][String.contains]` it.`[`name`][org.jetbrains.kotlinx.dataframe.DataColumn.name]` }`
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;`}`
+     *
+     * `}`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  { "colC"  `[`and`][kotlin.String.and]`  Type::colB  `[`and`][kotlin.reflect.KProperty.and]`  "pathTo"["colC"]  `[`and`][org.jetbrains.kotlinx.dataframe.columns.ColumnsResolver.and]` colD }`
+     *
+     * #### Example for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  { "colA"  `[`and`][kotlin.String.and]` `<code>`Type::colB`</code>` }`
+     *
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] that contains all the columns from the [ColumnsResolvers][org.jetbrains.kotlinx.dataframe.columns.ColumnsResolver] on the left
+     *   and right side of the [and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and] operator.
+     */
+    public infix fun <C> String.and(other: KProperty<C>): ColumnSet<*> = toColumnAccessor() and other
+
+    // endregion
+
+    // region KProperty
+
+    /**
+     * ## And Operator
+     * The [and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and] operator allows you to combine selections of columns or simply select multiple columns at once.
+     *
+     * You can even mix and match any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]!
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.Grammar]
+     *
+     * #### Examples:
+     *
+     * `df.`[`groupBy`][org.jetbrains.kotlinx.dataframe.DataFrame.groupBy]`  { "colA"  `[`and`][kotlin.String.and]` colB }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` {`
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;[`colsOf`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.colsOf]`<`[`String`][String]`>() `[`and`][org.jetbrains.kotlinx.dataframe.columns.ColumnsResolver.and]` {`
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;[`colsAtAnyDepth`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsAtAnyDepth]`  { "price"  `[`in`][String.contains]` it.`[`name`][org.jetbrains.kotlinx.dataframe.DataColumn.name]` }`
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;`}`
+     *
+     * `}`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  { "colC"  `[`and`][kotlin.String.and]`  Type::colB  `[`and`][kotlin.reflect.KProperty.and]`  "pathTo"["colC"]  `[`and`][org.jetbrains.kotlinx.dataframe.columns.ColumnsResolver.and]` colD }`
+     *
+     * #### Example for this overload:
+     *
+     * `df.`[select][DataFrame.select]`  { Type::colA  `[`and`][KProperty.and]` `<code></code>` }`
+     *
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] that contains all the columns from the [ColumnsResolvers][org.jetbrains.kotlinx.dataframe.columns.ColumnsResolver] on the left
+     *   and right side of the [and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and] operator.
+     */
+    private interface KPropertyAndDocs {
+
+        interface Argument
+    }
+
+    /** ## And Operator
+     * The [and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and] operator allows you to combine selections of columns or simply select multiple columns at once.
+     *
+     * You can even mix and match any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]!
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.Grammar]
+     *
+     * #### Examples:
+     *
+     * `df.`[`groupBy`][org.jetbrains.kotlinx.dataframe.DataFrame.groupBy]`  { "colA"  `[`and`][kotlin.String.and]` colB }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` {`
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;[`colsOf`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.colsOf]`<`[`String`][String]`>() `[`and`][org.jetbrains.kotlinx.dataframe.columns.ColumnsResolver.and]` {`
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;[`colsAtAnyDepth`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsAtAnyDepth]`  { "price"  `[`in`][String.contains]` it.`[`name`][org.jetbrains.kotlinx.dataframe.DataColumn.name]` }`
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;`}`
+     *
+     * `}`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  { "colC"  `[`and`][kotlin.String.and]`  Type::colB  `[`and`][kotlin.reflect.KProperty.and]`  "pathTo"["colC"]  `[`and`][org.jetbrains.kotlinx.dataframe.columns.ColumnsResolver.and]` colD }`
+     *
+     * #### Example for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  { Type::colA  `[`and`][kotlin.reflect.KProperty.and]` `<code>[`colsOf`][SingleColumn.colsOf]`<`[`Int`][Int]`>()`</code>` }`
+     *
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] that contains all the columns from the [ColumnsResolvers][org.jetbrains.kotlinx.dataframe.columns.ColumnsResolver] on the left
+     *   and right side of the [and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and] operator.
+     */
+    public infix fun <C> KProperty<C>.and(other: ColumnsResolver<C>): ColumnSet<C> = toColumnAccessor() and other
+
+    /** ## And Operator
+     * The [and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and] operator allows you to combine selections of columns or simply select multiple columns at once.
+     *
+     * You can even mix and match any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]!
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.Grammar]
+     *
+     * #### Examples:
+     *
+     * `df.`[`groupBy`][org.jetbrains.kotlinx.dataframe.DataFrame.groupBy]`  { "colA"  `[`and`][kotlin.String.and]` colB }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` {`
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;[`colsOf`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.colsOf]`<`[`String`][String]`>() `[`and`][org.jetbrains.kotlinx.dataframe.columns.ColumnsResolver.and]` {`
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;[`colsAtAnyDepth`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsAtAnyDepth]`  { "price"  `[`in`][String.contains]` it.`[`name`][org.jetbrains.kotlinx.dataframe.DataColumn.name]` }`
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;`}`
+     *
+     * `}`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  { "colC"  `[`and`][kotlin.String.and]`  Type::colB  `[`and`][kotlin.reflect.KProperty.and]`  "pathTo"["colC"]  `[`and`][org.jetbrains.kotlinx.dataframe.columns.ColumnsResolver.and]` colD }`
+     *
+     * #### Example for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  { Type::colA  `[`and`][kotlin.reflect.KProperty.and]` `<code>`{ colA `[/][DataColumn.div]`  2.0  `[`named`][ColumnReference.named]` "half colA" }`</code>` }`
+     *
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] that contains all the columns from the [ColumnsResolvers][org.jetbrains.kotlinx.dataframe.columns.ColumnsResolver] on the left
+     *   and right side of the [and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and] operator.
+     */
+    public infix fun <C> KProperty<C>.and(other: () -> ColumnsResolver<C>): ColumnSet<C> =
+        toColumnAccessor() and other()
+
+    /** ## And Operator
+     * The [and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and] operator allows you to combine selections of columns or simply select multiple columns at once.
+     *
+     * You can even mix and match any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]!
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.Grammar]
+     *
+     * #### Examples:
+     *
+     * `df.`[`groupBy`][org.jetbrains.kotlinx.dataframe.DataFrame.groupBy]`  { "colA"  `[`and`][kotlin.String.and]` colB }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` {`
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;[`colsOf`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.colsOf]`<`[`String`][String]`>() `[`and`][org.jetbrains.kotlinx.dataframe.columns.ColumnsResolver.and]` {`
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;[`colsAtAnyDepth`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsAtAnyDepth]`  { "price"  `[`in`][String.contains]` it.`[`name`][org.jetbrains.kotlinx.dataframe.DataColumn.name]` }`
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;`}`
+     *
+     * `}`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  { "colC"  `[`and`][kotlin.String.and]`  Type::colB  `[`and`][kotlin.reflect.KProperty.and]`  "pathTo"["colC"]  `[`and`][org.jetbrains.kotlinx.dataframe.columns.ColumnsResolver.and]` colD }`
+     *
+     * #### Example for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  { Type::colA  `[`and`][kotlin.reflect.KProperty.and]` `<code>`"colB"`</code>` }`
+     *
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] that contains all the columns from the [ColumnsResolvers][org.jetbrains.kotlinx.dataframe.columns.ColumnsResolver] on the left
+     *   and right side of the [and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and] operator.
+     */
+    public infix fun <C> KProperty<C>.and(other: String): ColumnSet<*> = toColumnAccessor() and other
+
+    /** ## And Operator
+     * The [and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and] operator allows you to combine selections of columns or simply select multiple columns at once.
+     *
+     * You can even mix and match any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]!
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.Grammar]
+     *
+     * #### Examples:
+     *
+     * `df.`[`groupBy`][org.jetbrains.kotlinx.dataframe.DataFrame.groupBy]`  { "colA"  `[`and`][kotlin.String.and]` colB }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` {`
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;[`colsOf`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.colsOf]`<`[`String`][String]`>() `[`and`][org.jetbrains.kotlinx.dataframe.columns.ColumnsResolver.and]` {`
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;[`colsAtAnyDepth`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsAtAnyDepth]`  { "price"  `[`in`][String.contains]` it.`[`name`][org.jetbrains.kotlinx.dataframe.DataColumn.name]` }`
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;`}`
+     *
+     * `}`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  { "colC"  `[`and`][kotlin.String.and]`  Type::colB  `[`and`][kotlin.reflect.KProperty.and]`  "pathTo"["colC"]  `[`and`][org.jetbrains.kotlinx.dataframe.columns.ColumnsResolver.and]` colD }`
+     *
+     * #### Example for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  { Type::colA  `[`and`][kotlin.reflect.KProperty.and]` `<code>`Type::colB`</code>` }`
+     *
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] that contains all the columns from the [ColumnsResolvers][org.jetbrains.kotlinx.dataframe.columns.ColumnsResolver] on the left
+     *   and right side of the [and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and] operator.
+     */
+    public infix fun <C> KProperty<C>.and(other: KProperty<C>): ColumnSet<C> =
+        toColumnAccessor() and other.toColumnAccessor()
+
+    // endregion
+}
+
+// endregion
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/any.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/any.kt
new file mode 100644
index 000000000..d8af3cf83
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/any.kt
@@ -0,0 +1,19 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import org.jetbrains.kotlinx.dataframe.DataColumn
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.Predicate
+import org.jetbrains.kotlinx.dataframe.RowFilter
+import org.jetbrains.kotlinx.dataframe.columns.values
+
+// region DataColumn
+
+public fun <T> DataColumn<T>.any(predicate: Predicate<T>): Boolean = values.any(predicate)
+
+// endregion
+
+// region DataFrame
+
+public fun <T> DataFrame<T>.any(predicate: RowFilter<T>): Boolean = rows().any { predicate(it, it) }
+
+// endregion
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/append.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/append.kt
new file mode 100644
index 000000000..6825337f6
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/append.kt
@@ -0,0 +1,32 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.columns.values
+import org.jetbrains.kotlinx.dataframe.impl.api.updateWith
+import org.jetbrains.kotlinx.dataframe.ncol
+import org.jetbrains.kotlinx.dataframe.nrow
+
+// region DataFrame
+
+public fun <T> DataFrame<T>.append(vararg values: Any?): DataFrame<T> {
+    val ncol = ncol
+    check(values.size % ncol == 0) {
+        "Invalid number of arguments. Multiple of $ncol is expected, but actual was: ${values.size}"
+    }
+    val newRows = values.size / ncol
+    return columns().mapIndexed { colIndex, col ->
+        val newValues = (0 until newRows).map { values[colIndex + it * ncol] }
+        col.updateWith(col.values + newValues)
+    }.toDataFrame().cast()
+}
+
+public fun <T> DataFrame<T>.appendNulls(numberOfRows: Int = 1): DataFrame<T> {
+    require(numberOfRows >= 0)
+    if (numberOfRows == 0) return this
+    if (ncol == 0) return DataFrame.empty(nrow + numberOfRows).cast()
+    return columns().map { col ->
+        col.updateWith(col.values + arrayOfNulls(numberOfRows))
+    }.toDataFrame().cast()
+}
+
+// endregion
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/asIterable.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/asIterable.kt
new file mode 100644
index 000000000..2b5c379f4
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/asIterable.kt
@@ -0,0 +1,9 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import org.jetbrains.kotlinx.dataframe.DataColumn
+
+// region DataColumn
+
+public fun <T> DataColumn<T>.asIterable(): Iterable<T> = values()
+
+// endregion
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/asSequence.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/asSequence.kt
new file mode 100644
index 000000000..73af1ef41
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/asSequence.kt
@@ -0,0 +1,17 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import org.jetbrains.kotlinx.dataframe.DataColumn
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.DataRow
+
+// region DataColumn
+
+public fun <T> DataColumn<T>.asSequence(): Sequence<T> = asIterable().asSequence()
+
+// endregion
+
+// region DataFrame
+
+public fun <T> DataFrame<T>.asSequence(): Sequence<DataRow<T>> = rows().asSequence()
+
+// endregion
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/associate.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/associate.kt
new file mode 100644
index 000000000..3e6d9fb44
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/associate.kt
@@ -0,0 +1,15 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.DataRow
+import org.jetbrains.kotlinx.dataframe.RowExpression
+
+// region DataFrame
+
+public fun <T, V> DataFrame<T>.associateBy(transform: RowExpression<T, V>): Map<V, DataRow<T>> =
+    rows().associateBy { transform(it, it) }
+
+public fun <T, K, V> DataFrame<T>.associate(transform: RowExpression<T, Pair<K, V>>): Map<K, V> =
+    rows().associate { transform(it, it) }
+
+// endregion
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/between.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/between.kt
new file mode 100644
index 000000000..3a37f9e7d
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/between.kt
@@ -0,0 +1,14 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import org.jetbrains.kotlinx.dataframe.DataColumn
+import org.jetbrains.kotlinx.dataframe.impl.between
+
+// region DataColumn
+
+public fun <T : Comparable<T>> DataColumn<T>.between(
+    left: T,
+    right: T,
+    includeBoundaries: Boolean = true,
+): DataColumn<Boolean> = map { it.between(left, right, includeBoundaries) }
+
+// endregion
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/cast.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/cast.kt
new file mode 100644
index 000000000..c8ba378c6
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/cast.kt
@@ -0,0 +1,71 @@
+@file:Suppress("UNCHECKED_CAST")
+
+package org.jetbrains.kotlinx.dataframe.api
+
+import org.jetbrains.kotlinx.dataframe.AnyCol
+import org.jetbrains.kotlinx.dataframe.AnyFrame
+import org.jetbrains.kotlinx.dataframe.AnyRow
+import org.jetbrains.kotlinx.dataframe.DataColumn
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.DataRow
+import org.jetbrains.kotlinx.dataframe.annotations.Check
+import org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor
+import org.jetbrains.kotlinx.dataframe.columns.ColumnGroup
+import org.jetbrains.kotlinx.dataframe.columns.ColumnReference
+import org.jetbrains.kotlinx.dataframe.columns.ColumnSet
+import org.jetbrains.kotlinx.dataframe.columns.ColumnWithPath
+import org.jetbrains.kotlinx.dataframe.columns.ColumnsResolver
+import org.jetbrains.kotlinx.dataframe.columns.FrameColumn
+import org.jetbrains.kotlinx.dataframe.columns.SingleColumn
+import org.jetbrains.kotlinx.dataframe.columns.ValueColumn
+import org.jetbrains.kotlinx.dataframe.impl.api.convertToImpl
+import org.jetbrains.kotlinx.dataframe.impl.columns.TransformableColumnSet
+import org.jetbrains.kotlinx.dataframe.impl.columns.TransformableSingleColumn
+import kotlin.reflect.typeOf
+
+@Check
+public fun <T> AnyFrame.cast(): DataFrame<T> = this as DataFrame<T>
+
+public inline fun <reified T> AnyFrame.cast(verify: Boolean = true): DataFrame<T> =
+    if (verify) {
+        convertToImpl(
+            typeOf<T>(),
+            allowConversion = false,
+            ExcessiveColumns.Keep,
+        ).cast()
+    } else {
+        cast()
+    }
+
+public inline fun <reified T> AnyFrame.castTo(
+    @Suppress("UNUSED_PARAMETER") schemaFrom: DataFrame<T>,
+    verify: Boolean = true,
+): DataFrame<T> = cast<T>(verify = verify)
+
+public fun <T> AnyRow.cast(): DataRow<T> = this as DataRow<T>
+
+public inline fun <reified T> AnyRow.cast(verify: Boolean = true): DataRow<T> = df().cast<T>(verify)[0]
+
+public fun <T> AnyCol.cast(): DataColumn<T> = this as DataColumn<T>
+
+public fun <T> ValueColumn<*>.cast(): ValueColumn<T> = this as ValueColumn<T>
+
+public fun <T> FrameColumn<*>.castFrameColumn(): FrameColumn<T> = this as FrameColumn<T>
+
+public fun <T> ColumnGroup<*>.cast(): ColumnGroup<T> = this as ColumnGroup<T>
+
+public fun <T> ColumnWithPath<*>.cast(): ColumnWithPath<T> = this as ColumnWithPath<T>
+
+public fun <T> ColumnAccessor<*>.cast(): ColumnAccessor<T> = this as ColumnAccessor<T>
+
+public fun <C> ColumnSet<*>.cast(): ColumnSet<C> = this as ColumnSet<C>
+
+public fun <C> ColumnsResolver<*>.cast(): ColumnsResolver<C> = this as ColumnsResolver<C>
+
+public fun <C> SingleColumn<*>.cast(): SingleColumn<C> = this as SingleColumn<C>
+
+public fun <C> TransformableColumnSet<*>.cast(): TransformableColumnSet<C> = this as TransformableColumnSet<C>
+
+public fun <C> TransformableSingleColumn<*>.cast(): TransformableSingleColumn<C> = this as TransformableSingleColumn<C>
+
+public fun <C> ColumnReference<*>.cast(): ColumnReference<C> = this as ColumnReference<C>
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/chunked.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/chunked.kt
new file mode 100644
index 000000000..67f3dec6d
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/chunked.kt
@@ -0,0 +1,25 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import org.jetbrains.kotlinx.dataframe.DataColumn
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.DataRow
+import org.jetbrains.kotlinx.dataframe.columns.ColumnGroup
+import org.jetbrains.kotlinx.dataframe.columns.FrameColumn
+import org.jetbrains.kotlinx.dataframe.columns.ValueColumn
+import org.jetbrains.kotlinx.dataframe.impl.getListType
+import org.jetbrains.kotlinx.dataframe.nrow
+import org.jetbrains.kotlinx.dataframe.type
+
+public fun <T> DataFrame<T>.chunked(size: Int, name: String = "groups"): FrameColumn<T> {
+    val startIndices = (0 until nrow step size)
+    return DataColumn.createFrameColumn(name, this, startIndices)
+}
+
+public fun <T> DataColumn<T>.chunked(size: Int): ValueColumn<List<T>> {
+    val values = toList().chunked(size)
+    return DataColumn.createValueColumn(name(), values, getListType(type))
+}
+
+public fun <T> ColumnGroup<T>.chunked(size: Int): FrameColumn<T> = chunked(size, name())
+
+public fun <T> DataColumn<DataRow<T>>.chunked(size: Int): FrameColumn<T> = asColumnGroup().chunked(size)
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/col.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/col.kt
new file mode 100644
index 000000000..813aa781c
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/col.kt
@@ -0,0 +1,3005 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import org.jetbrains.kotlinx.dataframe.AnyColumnGroupAccessor
+import org.jetbrains.kotlinx.dataframe.ColumnGroupReference
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.DataRow
+import org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.Grammar
+import org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor
+import org.jetbrains.kotlinx.dataframe.columns.ColumnGroup
+import org.jetbrains.kotlinx.dataframe.columns.ColumnPath
+import org.jetbrains.kotlinx.dataframe.columns.ColumnSet
+import org.jetbrains.kotlinx.dataframe.columns.SingleColumn
+import org.jetbrains.kotlinx.dataframe.impl.columns.getAt
+import org.jetbrains.kotlinx.dataframe.impl.columns.singleImpl
+import org.jetbrains.kotlinx.dataframe.impl.columns.transformSingle
+import org.jetbrains.kotlinx.dataframe.util.COL_REPLACE
+import org.jetbrains.kotlinx.dataframe.util.IDENTITY_FUNCTION
+import kotlin.reflect.KProperty
+
+// region ColumnsSelectionDsl
+
+/**
+ * ## Col [Columns Selection DSL][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl]
+ *
+ * See [Grammar] for all functions in this interface.
+ * @param _UNUSED [#KT-68546](https://youtrack.jetbrains.com/issue/KT-68546/Conflicting-overloads-in-non-generic-interface-K2-2.0.0)
+ */
+public interface ColColumnsSelectionDsl<out _UNUSED> {
+
+    /**
+     * ## Col Grammar
+     *
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * [(What is this notation?)][org.jetbrains.kotlinx.dataframe.documentation.DslGrammar]
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  ### Definitions:
+     *  `columnSet: `[`ColumnSet`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]`<*>`
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  `columnGroup: `[`SingleColumn`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]`<`[`DataRow`][org.jetbrains.kotlinx.dataframe.DataRow]`<*>> | `[`String`][String]`  |  `[`KProperty`][kotlin.reflect.KProperty]`<* | `[`DataRow`][org.jetbrains.kotlinx.dataframe.DataRow]`<*>> | `[`ColumnPath`][org.jetbrains.kotlinx.dataframe.columns.ColumnPath]
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  `column: `[`ColumnAccessor`][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor]`  |  `[`String`][String]`  | `[`KProperty`][kotlin.reflect.KProperty]`<*> | `[`ColumnPath`][org.jetbrains.kotlinx.dataframe.columns.ColumnPath]
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  `index: `[`Int`][Int]
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  `T: Column type`
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  ### What can be called directly in the [Columns Selection DSL][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl]:
+     *
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  [**`col`**][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.col]`[`**`<`**[`T`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ColumnTypeDef]**`>`**`]`**`(`**[`column`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ColumnDef]`  |  `[`index`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.IndexDef]**`)`**
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  ### What can be called on a [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]:
+     *
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  [`columnSet`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ColumnSetDef]
+     *
+     *  &nbsp;&nbsp;&nbsp;&nbsp;__`.`__[**`col`**][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.col]**`(`**[`index`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.IndexDef]**`)`**`  |  `[**`[`**][ColumnsSelectionDsl.col][`index`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.IndexDef][**`]`**][ColumnsSelectionDsl.col]
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  ### What can be called on a [Column Group (reference)][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ColumnGroupDef]:
+     *
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  [`columnGroup`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ColumnGroupDef]
+     *
+     *  &nbsp;&nbsp;&nbsp;&nbsp;__`.`__[**`col`**][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.col]`[`**`<`**[`T`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ColumnTypeDef]**`>`**`]`**`(`**[`column`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ColumnDef]`  |  `[`index`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.IndexDef]**`)`**
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     */
+    public interface Grammar {
+
+        /** [**`col`**][ColumnsSelectionDsl.col] */
+        public interface PlainDslName
+
+        /** __`.`__[**`col`**][ColumnsSelectionDsl.col] */
+        public interface ColumnSetName
+
+        /** __`.`__[**`col`**][ColumnsSelectionDsl.col] */
+        public interface ColumnGroupName
+    }
+
+    /**
+     * ## Col
+     *
+     * Creates a [ColumnAccessor] (or [SingleColumn]) for a column with the given argument which can be either
+     * an index ([Int]) or a reference to a column
+     * ([String], [ColumnPath], [KProperty], or [ColumnAccessor]; any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+     *
+     * This is a DSL-shorthand for [column] and can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index).
+     * The function can also be called on [ColumnGroups][ColumnGroupReference] to create
+     * an accessor for a column inside a [ColumnGroup].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     *
+     * ### Check out: [Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][DataFrame.select]`  {  `[col][col]`<`[String][String]`>("colA") }`
+     *
+     * `df.`[select][DataFrame.select]`  {  `[col][col]`(SomeType::colB) }`
+     *
+     * `df.`[select][DataFrame.select]` { myColumnGroup.`[col][col]`(1) }`
+     *
+     * #### Examples for this overload:
+     *
+     *
+     *
+     * To create a [ColumnAccessor] for a specific kind of column with runtime checks, take a look at the functions
+     * [valueCol][ColumnsSelectionDsl.valueCol],
+     * [colGroup][ColumnsSelectionDsl.colGroup],
+     * and [frameCol][ColumnsSelectionDsl.frameCol].
+     *
+     * @return A [ColumnAccessor] for the column with the given argument if possible, else a [SingleColumn].
+     * @throws [IllegalStateException] if the column with the given argument does not exist.
+     *
+     * @see [column]
+     * @see [ColumnsSelectionDsl.colGroup]
+     * @see [ColumnsSelectionDsl.frameCol]
+     * @see [ColumnsSelectionDsl.valueCol]
+     *
+     */
+    private interface CommonColDocs {
+
+        // Example argument, can be either {@include [SingleExample]} or {@include [DoubleExample]}
+        interface ExampleArg
+
+        /**
+         * `df.`[select][DataFrame.select]` { `[col][col]`() }`
+         */
+        interface SingleExample
+
+        /**
+         * `df.`[select][DataFrame.select]` { `[col][col]`() }`
+         *
+         * `df.`[select][DataFrame.select]` { `[col][col]`<`[String][String]`>() }`
+         */
+        interface DoubleExample
+
+        // Receiver argument for the example(s)
+        interface ReceiverArg
+
+        // Argument for the example(s)
+        interface Arg
+
+        // Optional note
+        interface Note
+
+        /** @param [C] The type of the column. */
+        interface ColumnTypeParam
+    }
+
+    // region reference
+
+    /**
+     * ## Col
+     *
+     * Creates a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] (or [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]) for a column with the given argument which can be either
+     * an index ([Int]) or a reference to a column
+     * ([String], [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath], [KProperty], or [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor]; any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+     *
+     * This is a DSL-shorthand for [column][org.jetbrains.kotlinx.dataframe.api.column] and can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index).
+     * The function can also be called on [ColumnGroups][org.jetbrains.kotlinx.dataframe.ColumnGroupReference] to create
+     * an accessor for a column inside a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[col][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.col]`<`[String][String]`>("colA") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[col][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.col]`(SomeType::colB) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[col][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.col]`(1) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { `[col][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.col]`(columnA) }`
+     *
+     * To create a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for a specific kind of column with runtime checks, take a look at the functions
+     * [valueCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.valueCol],
+     * [colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup],
+     * and [frameCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.frameCol].
+     *
+     * @return A [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for the column with the given argument if possible, else a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn].
+     * @throws [IllegalStateException] if the column with the given argument does not exist.
+     *
+     * @see [column]
+     * @see [ColumnsSelectionDsl.colGroup]
+     * @see [ColumnsSelectionDsl.frameCol]
+     * @see [ColumnsSelectionDsl.valueCol]
+     *
+     *
+     *
+     * @param [col] The [ColumnAccessor] pointing to the column.
+     * @param [C] The type of the column.
+     */
+    private interface ColReferenceDocs
+
+    /**
+     * ## Col
+     *
+     * Creates a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] (or [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]) for a column with the given argument which can be either
+     * an index ([Int]) or a reference to a column
+     * ([String], [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath], [KProperty], or [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor]; any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+     *
+     * This is a DSL-shorthand for [column][org.jetbrains.kotlinx.dataframe.api.column] and can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index).
+     * The function can also be called on [ColumnGroups][org.jetbrains.kotlinx.dataframe.ColumnGroupReference] to create
+     * an accessor for a column inside a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * NOTE: This overload is an identity function and can be omitted.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[col][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.col]`<`[String][String]`>("colA") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[col][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.col]`(SomeType::colB) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[col][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.col]`(1) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { `[col][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.col]`(columnA) }`
+     *
+     * To create a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for a specific kind of column with runtime checks, take a look at the functions
+     * [valueCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.valueCol],
+     * [colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup],
+     * and [frameCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.frameCol].
+     *
+     * @return A [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for the column with the given argument if possible, else a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn].
+     * @throws [IllegalStateException] if the column with the given argument does not exist.
+     *
+     * @see [column]
+     * @see [ColumnsSelectionDsl.colGroup]
+     * @see [ColumnsSelectionDsl.frameCol]
+     * @see [ColumnsSelectionDsl.valueCol]
+     *
+     *
+     *
+     * @param [col] The [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] pointing to the column.
+     * @param [C] The type of the column.
+     *
+     */
+    @Deprecated(IDENTITY_FUNCTION, ReplaceWith(COL_REPLACE))
+    public fun <C> col(col: ColumnAccessor<C>): ColumnAccessor<C> = col
+
+    /**
+     * ## Col
+     *
+     * Creates a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] (or [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]) for a column with the given argument which can be either
+     * an index ([Int]) or a reference to a column
+     * ([String], [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath], [KProperty], or [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor]; any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+     *
+     * This is a DSL-shorthand for [column][org.jetbrains.kotlinx.dataframe.api.column] and can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index).
+     * The function can also be called on [ColumnGroups][org.jetbrains.kotlinx.dataframe.ColumnGroupReference] to create
+     * an accessor for a column inside a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[col][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.col]`<`[String][String]`>("colA") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[col][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.col]`(SomeType::colB) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[col][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.col]`(1) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[col][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.col]`(columnA) }`
+     *
+     * To create a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for a specific kind of column with runtime checks, take a look at the functions
+     * [valueCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.valueCol],
+     * [colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup],
+     * and [frameCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.frameCol].
+     *
+     * @return A [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for the column with the given argument if possible, else a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn].
+     * @throws [IllegalStateException] if the column with the given argument does not exist.
+     *
+     * @see [column]
+     * @see [ColumnsSelectionDsl.colGroup]
+     * @see [ColumnsSelectionDsl.frameCol]
+     * @see [ColumnsSelectionDsl.valueCol]
+     *
+     *
+     *
+     * @param [col] The [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] pointing to the column.
+     * @param [C] The type of the column.
+     */
+    public fun <C> SingleColumn<DataRow<*>>.col(col: ColumnAccessor<C>): SingleColumn<C> =
+        this.ensureIsColumnGroup().transformSingle {
+            val child = it.getCol(col)
+                ?: throw IllegalStateException("Column '${col.path()}' not found in column group '${it.path}'")
+            listOf(child)
+        }.singleImpl()
+
+    /**
+     * ## Col
+     *
+     * Creates a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] (or [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]) for a column with the given argument which can be either
+     * an index ([Int]) or a reference to a column
+     * ([String], [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath], [KProperty], or [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor]; any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+     *
+     * This is a DSL-shorthand for [column][org.jetbrains.kotlinx.dataframe.api.column] and can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index).
+     * The function can also be called on [ColumnGroups][org.jetbrains.kotlinx.dataframe.ColumnGroupReference] to create
+     * an accessor for a column inside a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[col][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.col]`<`[String][String]`>("colA") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[col][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.col]`(SomeType::colB) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[col][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.col]`(1) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[col][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.col]`(columnA) }`
+     *
+     * To create a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for a specific kind of column with runtime checks, take a look at the functions
+     * [valueCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.valueCol],
+     * [colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup],
+     * and [frameCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.frameCol].
+     *
+     * @return A [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for the column with the given argument if possible, else a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn].
+     * @throws [IllegalStateException] if the column with the given argument does not exist.
+     *
+     * @see [column]
+     * @see [ColumnsSelectionDsl.colGroup]
+     * @see [ColumnsSelectionDsl.frameCol]
+     * @see [ColumnsSelectionDsl.valueCol]
+     *
+     *
+     *
+     * @param [col] The [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] pointing to the column.
+     * @param [C] The type of the column.
+     */
+    public fun <C> AnyColumnGroupAccessor.col(col: ColumnAccessor<C>): ColumnAccessor<C> =
+        this.ensureIsColumnGroup().column(col.path())
+
+    /**
+     * ## Col
+     *
+     * Creates a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] (or [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]) for a column with the given argument which can be either
+     * an index ([Int]) or a reference to a column
+     * ([String], [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath], [KProperty], or [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor]; any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+     *
+     * This is a DSL-shorthand for [column][org.jetbrains.kotlinx.dataframe.api.column] and can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index).
+     * The function can also be called on [ColumnGroups][org.jetbrains.kotlinx.dataframe.ColumnGroupReference] to create
+     * an accessor for a column inside a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[col][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.col]`<`[String][String]`>("colA") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[col][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.col]`(SomeType::colB) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[col][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.col]`(1) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "myColumnGroup".`[col][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.col]`(columnA) }`
+     *
+     * To create a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for a specific kind of column with runtime checks, take a look at the functions
+     * [valueCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.valueCol],
+     * [colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup],
+     * and [frameCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.frameCol].
+     *
+     * @return A [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for the column with the given argument if possible, else a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn].
+     * @throws [IllegalStateException] if the column with the given argument does not exist.
+     *
+     * @see [column]
+     * @see [ColumnsSelectionDsl.colGroup]
+     * @see [ColumnsSelectionDsl.frameCol]
+     * @see [ColumnsSelectionDsl.valueCol]
+     *
+     *
+     *
+     * @param [col] The [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] pointing to the column.
+     * @param [C] The type of the column.
+     */
+    public fun <C> String.col(col: ColumnAccessor<C>): ColumnAccessor<C> =
+        columnGroup(this).ensureIsColumnGroup().column(col.path())
+
+    /**
+     * ## Col
+     *
+     * Creates a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] (or [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]) for a column with the given argument which can be either
+     * an index ([Int]) or a reference to a column
+     * ([String], [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath], [KProperty], or [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor]; any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+     *
+     * This is a DSL-shorthand for [column][org.jetbrains.kotlinx.dataframe.api.column] and can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index).
+     * The function can also be called on [ColumnGroups][org.jetbrains.kotlinx.dataframe.ColumnGroupReference] to create
+     * an accessor for a column inside a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[col][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.col]`<`[String][String]`>("colA") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[col][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.col]`(SomeType::colB) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[col][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.col]`(1) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { Type::myColumnGroup.`[col][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.col]`(columnA) }`
+     *
+     * To create a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for a specific kind of column with runtime checks, take a look at the functions
+     * [valueCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.valueCol],
+     * [colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup],
+     * and [frameCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.frameCol].
+     *
+     * @return A [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for the column with the given argument if possible, else a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn].
+     * @throws [IllegalStateException] if the column with the given argument does not exist.
+     *
+     * @see [column]
+     * @see [ColumnsSelectionDsl.colGroup]
+     * @see [ColumnsSelectionDsl.frameCol]
+     * @see [ColumnsSelectionDsl.valueCol]
+     *
+     *
+     *
+     * @param [col] The [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] pointing to the column.
+     * @param [C] The type of the column.
+     */
+    public fun <C> KProperty<*>.col(col: ColumnAccessor<C>): ColumnAccessor<C> =
+        columnGroup(this).ensureIsColumnGroup().column(col.path())
+
+    /**
+     * ## Col
+     *
+     * Creates a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] (or [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]) for a column with the given argument which can be either
+     * an index ([Int]) or a reference to a column
+     * ([String], [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath], [KProperty], or [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor]; any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+     *
+     * This is a DSL-shorthand for [column][org.jetbrains.kotlinx.dataframe.api.column] and can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index).
+     * The function can also be called on [ColumnGroups][org.jetbrains.kotlinx.dataframe.ColumnGroupReference] to create
+     * an accessor for a column inside a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[col][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.col]`<`[String][String]`>("colA") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[col][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.col]`(SomeType::colB) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[col][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.col]`(1) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "pathTo"["myColumnGroup"].`[col][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.col]`(columnA) }`
+     *
+     * To create a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for a specific kind of column with runtime checks, take a look at the functions
+     * [valueCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.valueCol],
+     * [colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup],
+     * and [frameCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.frameCol].
+     *
+     * @return A [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for the column with the given argument if possible, else a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn].
+     * @throws [IllegalStateException] if the column with the given argument does not exist.
+     *
+     * @see [column]
+     * @see [ColumnsSelectionDsl.colGroup]
+     * @see [ColumnsSelectionDsl.frameCol]
+     * @see [ColumnsSelectionDsl.valueCol]
+     *
+     *
+     *
+     * @param [col] The [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] pointing to the column.
+     * @param [C] The type of the column.
+     */
+    public fun <C> ColumnPath.col(col: ColumnAccessor<C>): ColumnAccessor<C> =
+        columnGroup(this).ensureIsColumnGroup().column(col.path())
+
+    // endregion
+
+    // region name
+
+    /**
+     * ## Col
+     *
+     * Creates a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] (or [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]) for a column with the given argument which can be either
+     * an index ([Int]) or a reference to a column
+     * ([String], [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath], [KProperty], or [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor]; any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+     *
+     * This is a DSL-shorthand for [column][org.jetbrains.kotlinx.dataframe.api.column] and can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index).
+     * The function can also be called on [ColumnGroups][org.jetbrains.kotlinx.dataframe.ColumnGroupReference] to create
+     * an accessor for a column inside a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[col][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.col]`<`[String][String]`>("colA") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[col][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.col]`(SomeType::colB) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[col][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.col]`(1) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { `[col][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.col]`("columnName") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { `[col][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.col]`<`[String][String]`>("columnName") }`
+     *
+     * To create a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for a specific kind of column with runtime checks, take a look at the functions
+     * [valueCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.valueCol],
+     * [colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup],
+     * and [frameCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.frameCol].
+     *
+     * @return A [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for the column with the given argument if possible, else a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn].
+     * @throws [IllegalStateException] if the column with the given argument does not exist.
+     *
+     * @see [column]
+     * @see [ColumnsSelectionDsl.colGroup]
+     * @see [ColumnsSelectionDsl.frameCol]
+     * @see [ColumnsSelectionDsl.valueCol]
+     *
+     *
+     *
+     * @param [name] The name of the column.
+     */
+    private interface ColNameDocs
+
+    /**
+     * ## Col
+     *
+     * Creates a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] (or [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]) for a column with the given argument which can be either
+     * an index ([Int]) or a reference to a column
+     * ([String], [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath], [KProperty], or [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor]; any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+     *
+     * This is a DSL-shorthand for [column][org.jetbrains.kotlinx.dataframe.api.column] and can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index).
+     * The function can also be called on [ColumnGroups][org.jetbrains.kotlinx.dataframe.ColumnGroupReference] to create
+     * an accessor for a column inside a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[col][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.col]`<`[String][String]`>("colA") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[col][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.col]`(SomeType::colB) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[col][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.col]`(1) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { `[col][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.col]`("columnName") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { `[col][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.col]`<`[String][String]`>("columnName") }`
+     *
+     * To create a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for a specific kind of column with runtime checks, take a look at the functions
+     * [valueCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.valueCol],
+     * [colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup],
+     * and [frameCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.frameCol].
+     *
+     * @return A [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for the column with the given argument if possible, else a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn].
+     * @throws [IllegalStateException] if the column with the given argument does not exist.
+     *
+     * @see [column]
+     * @see [ColumnsSelectionDsl.colGroup]
+     * @see [ColumnsSelectionDsl.frameCol]
+     * @see [ColumnsSelectionDsl.valueCol]
+     *
+     *
+     *
+     * @param [name] The name of the column.
+     */
+    @Suppress("INAPPLICABLE_JVM_NAME")
+    @JvmName("colUnTyped")
+    public fun col(name: String): ColumnAccessor<*> = column<Any?>(name)
+
+    /**
+     * ## Col
+     *
+     * Creates a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] (or [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]) for a column with the given argument which can be either
+     * an index ([Int]) or a reference to a column
+     * ([String], [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath], [KProperty], or [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor]; any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+     *
+     * This is a DSL-shorthand for [column][org.jetbrains.kotlinx.dataframe.api.column] and can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index).
+     * The function can also be called on [ColumnGroups][org.jetbrains.kotlinx.dataframe.ColumnGroupReference] to create
+     * an accessor for a column inside a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[col][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.col]`<`[String][String]`>("colA") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[col][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.col]`(SomeType::colB) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[col][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.col]`(1) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { `[col][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.col]`("columnName") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { `[col][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.col]`<`[String][String]`>("columnName") }`
+     *
+     * To create a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for a specific kind of column with runtime checks, take a look at the functions
+     * [valueCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.valueCol],
+     * [colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup],
+     * and [frameCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.frameCol].
+     *
+     * @return A [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for the column with the given argument if possible, else a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn].
+     * @throws [IllegalStateException] if the column with the given argument does not exist.
+     *
+     * @see [column]
+     * @see [ColumnsSelectionDsl.colGroup]
+     * @see [ColumnsSelectionDsl.frameCol]
+     * @see [ColumnsSelectionDsl.valueCol]
+     *
+     *
+     *
+     * @param [name] The name of the column.
+     * @param [C] The type of the column.
+     */
+    public fun <C> col(name: String): ColumnAccessor<C> = column(name)
+
+    /**
+     * ## Col
+     *
+     * Creates a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] (or [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]) for a column with the given argument which can be either
+     * an index ([Int]) or a reference to a column
+     * ([String], [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath], [KProperty], or [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor]; any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+     *
+     * This is a DSL-shorthand for [column][org.jetbrains.kotlinx.dataframe.api.column] and can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index).
+     * The function can also be called on [ColumnGroups][org.jetbrains.kotlinx.dataframe.ColumnGroupReference] to create
+     * an accessor for a column inside a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[col][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.col]`<`[String][String]`>("colA") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[col][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.col]`(SomeType::colB) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[col][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.col]`(1) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[col][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.col]`("columnName") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[col][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.col]`<`[String][String]`>("columnName") }`
+     *
+     * To create a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for a specific kind of column with runtime checks, take a look at the functions
+     * [valueCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.valueCol],
+     * [colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup],
+     * and [frameCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.frameCol].
+     *
+     * @return A [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for the column with the given argument if possible, else a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn].
+     * @throws [IllegalStateException] if the column with the given argument does not exist.
+     *
+     * @see [column]
+     * @see [ColumnsSelectionDsl.colGroup]
+     * @see [ColumnsSelectionDsl.frameCol]
+     * @see [ColumnsSelectionDsl.valueCol]
+     *
+     *
+     *
+     * @param [name] The name of the column.
+     */
+    @Suppress("INAPPLICABLE_JVM_NAME")
+    @JvmName("colUnTyped")
+    public fun SingleColumn<DataRow<*>>.col(name: String): SingleColumn<*> = col<Any?>(name)
+
+    /**
+     * ## Col
+     *
+     * Creates a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] (or [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]) for a column with the given argument which can be either
+     * an index ([Int]) or a reference to a column
+     * ([String], [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath], [KProperty], or [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor]; any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+     *
+     * This is a DSL-shorthand for [column][org.jetbrains.kotlinx.dataframe.api.column] and can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index).
+     * The function can also be called on [ColumnGroups][org.jetbrains.kotlinx.dataframe.ColumnGroupReference] to create
+     * an accessor for a column inside a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[col][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.col]`<`[String][String]`>("colA") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[col][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.col]`(SomeType::colB) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[col][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.col]`(1) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[col][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.col]`("columnName") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[col][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.col]`<`[String][String]`>("columnName") }`
+     *
+     * To create a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for a specific kind of column with runtime checks, take a look at the functions
+     * [valueCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.valueCol],
+     * [colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup],
+     * and [frameCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.frameCol].
+     *
+     * @return A [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for the column with the given argument if possible, else a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn].
+     * @throws [IllegalStateException] if the column with the given argument does not exist.
+     *
+     * @see [column]
+     * @see [ColumnsSelectionDsl.colGroup]
+     * @see [ColumnsSelectionDsl.frameCol]
+     * @see [ColumnsSelectionDsl.valueCol]
+     *
+     *
+     *
+     * @param [name] The name of the column.
+     * @param [C] The type of the column.
+     */
+    public fun <C> SingleColumn<DataRow<*>>.col(name: String): SingleColumn<C> =
+        this.ensureIsColumnGroup().transformSingle {
+            val child = it.getCol(name)?.cast<C>()
+                ?: throw IllegalStateException("Column '$name' not found in column group '${it.path}'")
+            listOf(child)
+        }.singleImpl()
+
+    /**
+     * ## Col
+     *
+     * Creates a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] (or [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]) for a column with the given argument which can be either
+     * an index ([Int]) or a reference to a column
+     * ([String], [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath], [KProperty], or [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor]; any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+     *
+     * This is a DSL-shorthand for [column][org.jetbrains.kotlinx.dataframe.api.column] and can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index).
+     * The function can also be called on [ColumnGroups][org.jetbrains.kotlinx.dataframe.ColumnGroupReference] to create
+     * an accessor for a column inside a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[col][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.col]`<`[String][String]`>("colA") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[col][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.col]`(SomeType::colB) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[col][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.col]`(1) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[col][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.col]`("columnName") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[col][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.col]`<`[String][String]`>("columnName") }`
+     *
+     * To create a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for a specific kind of column with runtime checks, take a look at the functions
+     * [valueCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.valueCol],
+     * [colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup],
+     * and [frameCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.frameCol].
+     *
+     * @return A [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for the column with the given argument if possible, else a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn].
+     * @throws [IllegalStateException] if the column with the given argument does not exist.
+     *
+     * @see [column]
+     * @see [ColumnsSelectionDsl.colGroup]
+     * @see [ColumnsSelectionDsl.frameCol]
+     * @see [ColumnsSelectionDsl.valueCol]
+     *
+     *
+     *
+     * @param [name] The name of the column.
+     */
+    @Suppress("INAPPLICABLE_JVM_NAME")
+    @JvmName("colUnTyped")
+    public fun AnyColumnGroupAccessor.col(name: String): ColumnAccessor<*> = col<Any?>(name)
+
+    /**
+     * ## Col
+     *
+     * Creates a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] (or [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]) for a column with the given argument which can be either
+     * an index ([Int]) or a reference to a column
+     * ([String], [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath], [KProperty], or [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor]; any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+     *
+     * This is a DSL-shorthand for [column][org.jetbrains.kotlinx.dataframe.api.column] and can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index).
+     * The function can also be called on [ColumnGroups][org.jetbrains.kotlinx.dataframe.ColumnGroupReference] to create
+     * an accessor for a column inside a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[col][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.col]`<`[String][String]`>("colA") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[col][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.col]`(SomeType::colB) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[col][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.col]`(1) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[col][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.col]`("columnName") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[col][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.col]`<`[String][String]`>("columnName") }`
+     *
+     * To create a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for a specific kind of column with runtime checks, take a look at the functions
+     * [valueCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.valueCol],
+     * [colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup],
+     * and [frameCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.frameCol].
+     *
+     * @return A [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for the column with the given argument if possible, else a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn].
+     * @throws [IllegalStateException] if the column with the given argument does not exist.
+     *
+     * @see [column]
+     * @see [ColumnsSelectionDsl.colGroup]
+     * @see [ColumnsSelectionDsl.frameCol]
+     * @see [ColumnsSelectionDsl.valueCol]
+     *
+     *
+     *
+     * @param [name] The name of the column.
+     * @param [C] The type of the column.
+     */
+    public fun <C> AnyColumnGroupAccessor.col(name: String): ColumnAccessor<C> = this.ensureIsColumnGroup().column(name)
+
+    /**
+     * ## Col
+     *
+     * Creates a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] (or [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]) for a column with the given argument which can be either
+     * an index ([Int]) or a reference to a column
+     * ([String], [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath], [KProperty], or [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor]; any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+     *
+     * This is a DSL-shorthand for [column][org.jetbrains.kotlinx.dataframe.api.column] and can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index).
+     * The function can also be called on [ColumnGroups][org.jetbrains.kotlinx.dataframe.ColumnGroupReference] to create
+     * an accessor for a column inside a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[col][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.col]`<`[String][String]`>("colA") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[col][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.col]`(SomeType::colB) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[col][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.col]`(1) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "myColumnGroup".`[col][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.col]`("columnName") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "myColumnGroup".`[col][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.col]`<`[String][String]`>("columnName") }`
+     *
+     * To create a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for a specific kind of column with runtime checks, take a look at the functions
+     * [valueCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.valueCol],
+     * [colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup],
+     * and [frameCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.frameCol].
+     *
+     * @return A [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for the column with the given argument if possible, else a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn].
+     * @throws [IllegalStateException] if the column with the given argument does not exist.
+     *
+     * @see [column]
+     * @see [ColumnsSelectionDsl.colGroup]
+     * @see [ColumnsSelectionDsl.frameCol]
+     * @see [ColumnsSelectionDsl.valueCol]
+     *
+     *
+     *
+     * @param [name] The name of the column.
+     */
+    @Suppress("INAPPLICABLE_JVM_NAME")
+    @JvmName("colUnTyped")
+    public fun String.col(name: String): ColumnAccessor<*> = col<Any?>(name)
+
+    /**
+     * ## Col
+     *
+     * Creates a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] (or [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]) for a column with the given argument which can be either
+     * an index ([Int]) or a reference to a column
+     * ([String], [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath], [KProperty], or [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor]; any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+     *
+     * This is a DSL-shorthand for [column][org.jetbrains.kotlinx.dataframe.api.column] and can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index).
+     * The function can also be called on [ColumnGroups][org.jetbrains.kotlinx.dataframe.ColumnGroupReference] to create
+     * an accessor for a column inside a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[col][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.col]`<`[String][String]`>("colA") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[col][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.col]`(SomeType::colB) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[col][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.col]`(1) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "myColumnGroup".`[col][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.col]`("columnName") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "myColumnGroup".`[col][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.col]`<`[String][String]`>("columnName") }`
+     *
+     * To create a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for a specific kind of column with runtime checks, take a look at the functions
+     * [valueCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.valueCol],
+     * [colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup],
+     * and [frameCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.frameCol].
+     *
+     * @return A [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for the column with the given argument if possible, else a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn].
+     * @throws [IllegalStateException] if the column with the given argument does not exist.
+     *
+     * @see [column]
+     * @see [ColumnsSelectionDsl.colGroup]
+     * @see [ColumnsSelectionDsl.frameCol]
+     * @see [ColumnsSelectionDsl.valueCol]
+     *
+     *
+     *
+     * @param [name] The name of the column.
+     * @param [C] The type of the column.
+     */
+    public fun <C> String.col(name: String): ColumnAccessor<C> =
+        columnGroup(this)
+            .ensureIsColumnGroup()
+            .column(name)
+
+    /**
+     * ## Col
+     *
+     * Creates a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] (or [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]) for a column with the given argument which can be either
+     * an index ([Int]) or a reference to a column
+     * ([String], [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath], [KProperty], or [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor]; any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+     *
+     * This is a DSL-shorthand for [column][org.jetbrains.kotlinx.dataframe.api.column] and can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index).
+     * The function can also be called on [ColumnGroups][org.jetbrains.kotlinx.dataframe.ColumnGroupReference] to create
+     * an accessor for a column inside a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[col][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.col]`<`[String][String]`>("colA") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[col][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.col]`(SomeType::colB) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[col][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.col]`(1) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { Type::myColumnGroup.`[col][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.col]`("columnName") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { Type::myColumnGroup.`[col][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.col]`<`[String][String]`>("columnName") }`
+     *
+     * To create a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for a specific kind of column with runtime checks, take a look at the functions
+     * [valueCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.valueCol],
+     * [colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup],
+     * and [frameCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.frameCol].
+     *
+     * @return A [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for the column with the given argument if possible, else a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn].
+     * @throws [IllegalStateException] if the column with the given argument does not exist.
+     *
+     * @see [column]
+     * @see [ColumnsSelectionDsl.colGroup]
+     * @see [ColumnsSelectionDsl.frameCol]
+     * @see [ColumnsSelectionDsl.valueCol]
+     *
+     *
+     *
+     * @param [name] The name of the column.
+     */
+    @Suppress("INAPPLICABLE_JVM_NAME")
+    @JvmName("colUnTyped")
+    public fun KProperty<*>.col(name: String): ColumnAccessor<*> = col<Any?>(name)
+
+    /**
+     * ## Col
+     *
+     * Creates a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] (or [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]) for a column with the given argument which can be either
+     * an index ([Int]) or a reference to a column
+     * ([String], [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath], [KProperty], or [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor]; any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+     *
+     * This is a DSL-shorthand for [column][org.jetbrains.kotlinx.dataframe.api.column] and can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index).
+     * The function can also be called on [ColumnGroups][org.jetbrains.kotlinx.dataframe.ColumnGroupReference] to create
+     * an accessor for a column inside a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[col][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.col]`<`[String][String]`>("colA") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[col][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.col]`(SomeType::colB) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[col][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.col]`(1) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { Type::myColumnGroup.`[col][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.col]`("columnName") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { Type::myColumnGroup.`[col][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.col]`<`[String][String]`>("columnName") }`
+     *
+     * To create a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for a specific kind of column with runtime checks, take a look at the functions
+     * [valueCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.valueCol],
+     * [colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup],
+     * and [frameCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.frameCol].
+     *
+     * @return A [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for the column with the given argument if possible, else a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn].
+     * @throws [IllegalStateException] if the column with the given argument does not exist.
+     *
+     * @see [column]
+     * @see [ColumnsSelectionDsl.colGroup]
+     * @see [ColumnsSelectionDsl.frameCol]
+     * @see [ColumnsSelectionDsl.valueCol]
+     *
+     *
+     *
+     * @param [name] The name of the column.
+     * @param [C] The type of the column.
+     */
+    public fun <C> KProperty<*>.col(name: String): ColumnAccessor<C> =
+        columnGroup(this).ensureIsColumnGroup().column(name)
+
+    /**
+     * ## Col
+     *
+     * Creates a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] (or [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]) for a column with the given argument which can be either
+     * an index ([Int]) or a reference to a column
+     * ([String], [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath], [KProperty], or [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor]; any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+     *
+     * This is a DSL-shorthand for [column][org.jetbrains.kotlinx.dataframe.api.column] and can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index).
+     * The function can also be called on [ColumnGroups][org.jetbrains.kotlinx.dataframe.ColumnGroupReference] to create
+     * an accessor for a column inside a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[col][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.col]`<`[String][String]`>("colA") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[col][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.col]`(SomeType::colB) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[col][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.col]`(1) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "pathTo"["myColumnGroup"].`[col][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.col]`("columnName") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "pathTo"["myColumnGroup"].`[col][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.col]`<`[String][String]`>("columnName") }`
+     *
+     * To create a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for a specific kind of column with runtime checks, take a look at the functions
+     * [valueCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.valueCol],
+     * [colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup],
+     * and [frameCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.frameCol].
+     *
+     * @return A [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for the column with the given argument if possible, else a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn].
+     * @throws [IllegalStateException] if the column with the given argument does not exist.
+     *
+     * @see [column]
+     * @see [ColumnsSelectionDsl.colGroup]
+     * @see [ColumnsSelectionDsl.frameCol]
+     * @see [ColumnsSelectionDsl.valueCol]
+     *
+     *
+     *
+     * @param [name] The name of the column.
+     */
+    @Suppress("INAPPLICABLE_JVM_NAME")
+    @JvmName("colUnTyped")
+    public fun ColumnPath.col(name: String): ColumnAccessor<*> = col<Any?>(name)
+
+    /**
+     * ## Col
+     *
+     * Creates a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] (or [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]) for a column with the given argument which can be either
+     * an index ([Int]) or a reference to a column
+     * ([String], [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath], [KProperty], or [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor]; any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+     *
+     * This is a DSL-shorthand for [column][org.jetbrains.kotlinx.dataframe.api.column] and can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index).
+     * The function can also be called on [ColumnGroups][org.jetbrains.kotlinx.dataframe.ColumnGroupReference] to create
+     * an accessor for a column inside a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[col][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.col]`<`[String][String]`>("colA") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[col][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.col]`(SomeType::colB) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[col][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.col]`(1) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "pathTo"["myColumnGroup"].`[col][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.col]`("columnName") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "pathTo"["myColumnGroup"].`[col][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.col]`<`[String][String]`>("columnName") }`
+     *
+     * To create a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for a specific kind of column with runtime checks, take a look at the functions
+     * [valueCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.valueCol],
+     * [colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup],
+     * and [frameCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.frameCol].
+     *
+     * @return A [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for the column with the given argument if possible, else a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn].
+     * @throws [IllegalStateException] if the column with the given argument does not exist.
+     *
+     * @see [column]
+     * @see [ColumnsSelectionDsl.colGroup]
+     * @see [ColumnsSelectionDsl.frameCol]
+     * @see [ColumnsSelectionDsl.valueCol]
+     *
+     *
+     *
+     * @param [name] The name of the column.
+     * @param [C] The type of the column.
+     */
+    public fun <C> ColumnPath.col(name: String): ColumnAccessor<C> =
+        columnGroup(this).ensureIsColumnGroup().column(name)
+
+    // endregion
+
+    // region path
+
+    /**
+     * ## Col
+     *
+     * Creates a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] (or [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]) for a column with the given argument which can be either
+     * an index ([Int]) or a reference to a column
+     * ([String], [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath], [KProperty], or [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor]; any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+     *
+     * This is a DSL-shorthand for [column][org.jetbrains.kotlinx.dataframe.api.column] and can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index).
+     * The function can also be called on [ColumnGroups][org.jetbrains.kotlinx.dataframe.ColumnGroupReference] to create
+     * an accessor for a column inside a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[col][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.col]`<`[String][String]`>("colA") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[col][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.col]`(SomeType::colB) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[col][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.col]`(1) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { `[col][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.col]`("pathTo"["columnName"] ) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { `[col][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.col]`<`[String][String]`>("pathTo"["columnName"] ) }`
+     *
+     * To create a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for a specific kind of column with runtime checks, take a look at the functions
+     * [valueCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.valueCol],
+     * [colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup],
+     * and [frameCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.frameCol].
+     *
+     * @return A [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for the column with the given argument if possible, else a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn].
+     * @throws [IllegalStateException] if the column with the given argument does not exist.
+     *
+     * @see [column]
+     * @see [ColumnsSelectionDsl.colGroup]
+     * @see [ColumnsSelectionDsl.frameCol]
+     * @see [ColumnsSelectionDsl.valueCol]
+     *
+     *
+     *
+     * @param [path] The path to the column.
+     */
+    private interface ColPathDocs
+
+    /**
+     * ## Col
+     *
+     * Creates a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] (or [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]) for a column with the given argument which can be either
+     * an index ([Int]) or a reference to a column
+     * ([String], [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath], [KProperty], or [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor]; any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+     *
+     * This is a DSL-shorthand for [column][org.jetbrains.kotlinx.dataframe.api.column] and can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index).
+     * The function can also be called on [ColumnGroups][org.jetbrains.kotlinx.dataframe.ColumnGroupReference] to create
+     * an accessor for a column inside a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[col][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.col]`<`[String][String]`>("colA") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[col][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.col]`(SomeType::colB) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[col][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.col]`(1) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { `[col][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.col]`("pathTo"["columnName"] ) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { `[col][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.col]`<`[String][String]`>("pathTo"["columnName"] ) }`
+     *
+     * To create a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for a specific kind of column with runtime checks, take a look at the functions
+     * [valueCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.valueCol],
+     * [colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup],
+     * and [frameCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.frameCol].
+     *
+     * @return A [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for the column with the given argument if possible, else a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn].
+     * @throws [IllegalStateException] if the column with the given argument does not exist.
+     *
+     * @see [column]
+     * @see [ColumnsSelectionDsl.colGroup]
+     * @see [ColumnsSelectionDsl.frameCol]
+     * @see [ColumnsSelectionDsl.valueCol]
+     *
+     *
+     *
+     * @param [path] The path to the column.
+     */
+    @Suppress("INAPPLICABLE_JVM_NAME")
+    @JvmName("colUnTyped")
+    public fun col(path: ColumnPath): ColumnAccessor<*> = column<Any?>(path)
+
+    /**
+     * ## Col
+     *
+     * Creates a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] (or [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]) for a column with the given argument which can be either
+     * an index ([Int]) or a reference to a column
+     * ([String], [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath], [KProperty], or [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor]; any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+     *
+     * This is a DSL-shorthand for [column][org.jetbrains.kotlinx.dataframe.api.column] and can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index).
+     * The function can also be called on [ColumnGroups][org.jetbrains.kotlinx.dataframe.ColumnGroupReference] to create
+     * an accessor for a column inside a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[col][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.col]`<`[String][String]`>("colA") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[col][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.col]`(SomeType::colB) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[col][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.col]`(1) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { `[col][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.col]`("pathTo"["columnName"] ) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { `[col][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.col]`<`[String][String]`>("pathTo"["columnName"] ) }`
+     *
+     * To create a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for a specific kind of column with runtime checks, take a look at the functions
+     * [valueCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.valueCol],
+     * [colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup],
+     * and [frameCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.frameCol].
+     *
+     * @return A [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for the column with the given argument if possible, else a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn].
+     * @throws [IllegalStateException] if the column with the given argument does not exist.
+     *
+     * @see [column]
+     * @see [ColumnsSelectionDsl.colGroup]
+     * @see [ColumnsSelectionDsl.frameCol]
+     * @see [ColumnsSelectionDsl.valueCol]
+     *
+     *
+     *
+     * @param [path] The path to the column.
+     * @param [C] The type of the column.
+     */
+    public fun <C> col(path: ColumnPath): ColumnAccessor<C> = column(path)
+
+    /**
+     * ## Col
+     *
+     * Creates a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] (or [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]) for a column with the given argument which can be either
+     * an index ([Int]) or a reference to a column
+     * ([String], [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath], [KProperty], or [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor]; any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+     *
+     * This is a DSL-shorthand for [column][org.jetbrains.kotlinx.dataframe.api.column] and can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index).
+     * The function can also be called on [ColumnGroups][org.jetbrains.kotlinx.dataframe.ColumnGroupReference] to create
+     * an accessor for a column inside a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[col][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.col]`<`[String][String]`>("colA") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[col][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.col]`(SomeType::colB) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[col][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.col]`(1) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[col][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.col]`("pathTo"["columnName"] ) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[col][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.col]`<`[String][String]`>("pathTo"["columnName"] ) }`
+     *
+     * To create a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for a specific kind of column with runtime checks, take a look at the functions
+     * [valueCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.valueCol],
+     * [colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup],
+     * and [frameCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.frameCol].
+     *
+     * @return A [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for the column with the given argument if possible, else a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn].
+     * @throws [IllegalStateException] if the column with the given argument does not exist.
+     *
+     * @see [column]
+     * @see [ColumnsSelectionDsl.colGroup]
+     * @see [ColumnsSelectionDsl.frameCol]
+     * @see [ColumnsSelectionDsl.valueCol]
+     *
+     *
+     *
+     * @param [path] The path to the column.
+     */
+    @Suppress("INAPPLICABLE_JVM_NAME")
+    @JvmName("colUnTyped")
+    public fun SingleColumn<DataRow<*>>.col(path: ColumnPath): SingleColumn<*> = col<Any?>(path)
+
+    /**
+     * ## Col
+     *
+     * Creates a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] (or [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]) for a column with the given argument which can be either
+     * an index ([Int]) or a reference to a column
+     * ([String], [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath], [KProperty], or [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor]; any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+     *
+     * This is a DSL-shorthand for [column][org.jetbrains.kotlinx.dataframe.api.column] and can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index).
+     * The function can also be called on [ColumnGroups][org.jetbrains.kotlinx.dataframe.ColumnGroupReference] to create
+     * an accessor for a column inside a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[col][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.col]`<`[String][String]`>("colA") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[col][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.col]`(SomeType::colB) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[col][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.col]`(1) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[col][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.col]`("pathTo"["columnName"] ) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[col][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.col]`<`[String][String]`>("pathTo"["columnName"] ) }`
+     *
+     * To create a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for a specific kind of column with runtime checks, take a look at the functions
+     * [valueCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.valueCol],
+     * [colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup],
+     * and [frameCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.frameCol].
+     *
+     * @return A [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for the column with the given argument if possible, else a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn].
+     * @throws [IllegalStateException] if the column with the given argument does not exist.
+     *
+     * @see [column]
+     * @see [ColumnsSelectionDsl.colGroup]
+     * @see [ColumnsSelectionDsl.frameCol]
+     * @see [ColumnsSelectionDsl.valueCol]
+     *
+     *
+     *
+     * @param [path] The path to the column.
+     * @param [C] The type of the column.
+     */
+    public fun <C> SingleColumn<DataRow<*>>.col(path: ColumnPath): SingleColumn<C> =
+        this.ensureIsColumnGroup().transformSingle {
+            val child = it.getCol(path)?.cast<C>()
+                ?: throw IllegalStateException("Column '$path' not found in column group '${it.path}'")
+            listOf(child)
+        }.singleImpl()
+
+    /**
+     * ## Col
+     *
+     * Creates a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] (or [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]) for a column with the given argument which can be either
+     * an index ([Int]) or a reference to a column
+     * ([String], [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath], [KProperty], or [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor]; any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+     *
+     * This is a DSL-shorthand for [column][org.jetbrains.kotlinx.dataframe.api.column] and can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index).
+     * The function can also be called on [ColumnGroups][org.jetbrains.kotlinx.dataframe.ColumnGroupReference] to create
+     * an accessor for a column inside a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[col][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.col]`<`[String][String]`>("colA") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[col][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.col]`(SomeType::colB) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[col][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.col]`(1) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[col][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.col]`("pathTo"["columnName"] ) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[col][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.col]`<`[String][String]`>("pathTo"["columnName"] ) }`
+     *
+     * To create a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for a specific kind of column with runtime checks, take a look at the functions
+     * [valueCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.valueCol],
+     * [colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup],
+     * and [frameCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.frameCol].
+     *
+     * @return A [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for the column with the given argument if possible, else a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn].
+     * @throws [IllegalStateException] if the column with the given argument does not exist.
+     *
+     * @see [column]
+     * @see [ColumnsSelectionDsl.colGroup]
+     * @see [ColumnsSelectionDsl.frameCol]
+     * @see [ColumnsSelectionDsl.valueCol]
+     *
+     *
+     *
+     * @param [path] The path to the column.
+     */
+    @Suppress("INAPPLICABLE_JVM_NAME")
+    @JvmName("colUnTyped")
+    public fun AnyColumnGroupAccessor.col(path: ColumnPath): ColumnAccessor<*> = col<Any?>(path)
+
+    /**
+     * ## Col
+     *
+     * Creates a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] (or [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]) for a column with the given argument which can be either
+     * an index ([Int]) or a reference to a column
+     * ([String], [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath], [KProperty], or [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor]; any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+     *
+     * This is a DSL-shorthand for [column][org.jetbrains.kotlinx.dataframe.api.column] and can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index).
+     * The function can also be called on [ColumnGroups][org.jetbrains.kotlinx.dataframe.ColumnGroupReference] to create
+     * an accessor for a column inside a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[col][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.col]`<`[String][String]`>("colA") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[col][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.col]`(SomeType::colB) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[col][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.col]`(1) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[col][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.col]`("pathTo"["columnName"] ) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[col][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.col]`<`[String][String]`>("pathTo"["columnName"] ) }`
+     *
+     * To create a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for a specific kind of column with runtime checks, take a look at the functions
+     * [valueCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.valueCol],
+     * [colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup],
+     * and [frameCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.frameCol].
+     *
+     * @return A [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for the column with the given argument if possible, else a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn].
+     * @throws [IllegalStateException] if the column with the given argument does not exist.
+     *
+     * @see [column]
+     * @see [ColumnsSelectionDsl.colGroup]
+     * @see [ColumnsSelectionDsl.frameCol]
+     * @see [ColumnsSelectionDsl.valueCol]
+     *
+     *
+     *
+     * @param [path] The path to the column.
+     * @param [C] The type of the column.
+     */
+    public fun <C> AnyColumnGroupAccessor.col(path: ColumnPath): ColumnAccessor<C> =
+        this.ensureIsColumnGroup().column(path)
+
+    /**
+     * ## Col
+     *
+     * Creates a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] (or [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]) for a column with the given argument which can be either
+     * an index ([Int]) or a reference to a column
+     * ([String], [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath], [KProperty], or [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor]; any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+     *
+     * This is a DSL-shorthand for [column][org.jetbrains.kotlinx.dataframe.api.column] and can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index).
+     * The function can also be called on [ColumnGroups][org.jetbrains.kotlinx.dataframe.ColumnGroupReference] to create
+     * an accessor for a column inside a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[col][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.col]`<`[String][String]`>("colA") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[col][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.col]`(SomeType::colB) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[col][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.col]`(1) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "myColumnGroup".`[col][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.col]`("pathTo"["columnName"] ) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "myColumnGroup".`[col][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.col]`<`[String][String]`>("pathTo"["columnName"] ) }`
+     *
+     * To create a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for a specific kind of column with runtime checks, take a look at the functions
+     * [valueCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.valueCol],
+     * [colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup],
+     * and [frameCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.frameCol].
+     *
+     * @return A [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for the column with the given argument if possible, else a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn].
+     * @throws [IllegalStateException] if the column with the given argument does not exist.
+     *
+     * @see [column]
+     * @see [ColumnsSelectionDsl.colGroup]
+     * @see [ColumnsSelectionDsl.frameCol]
+     * @see [ColumnsSelectionDsl.valueCol]
+     *
+     *
+     *
+     * @param [path] The path to the column.
+     */
+    @Suppress("INAPPLICABLE_JVM_NAME")
+    @JvmName("colUnTyped")
+    public fun String.col(path: ColumnPath): ColumnAccessor<*> = col<Any?>(path)
+
+    /**
+     * ## Col
+     *
+     * Creates a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] (or [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]) for a column with the given argument which can be either
+     * an index ([Int]) or a reference to a column
+     * ([String], [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath], [KProperty], or [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor]; any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+     *
+     * This is a DSL-shorthand for [column][org.jetbrains.kotlinx.dataframe.api.column] and can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index).
+     * The function can also be called on [ColumnGroups][org.jetbrains.kotlinx.dataframe.ColumnGroupReference] to create
+     * an accessor for a column inside a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[col][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.col]`<`[String][String]`>("colA") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[col][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.col]`(SomeType::colB) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[col][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.col]`(1) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "myColumnGroup".`[col][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.col]`("pathTo"["columnName"] ) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "myColumnGroup".`[col][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.col]`<`[String][String]`>("pathTo"["columnName"] ) }`
+     *
+     * To create a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for a specific kind of column with runtime checks, take a look at the functions
+     * [valueCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.valueCol],
+     * [colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup],
+     * and [frameCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.frameCol].
+     *
+     * @return A [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for the column with the given argument if possible, else a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn].
+     * @throws [IllegalStateException] if the column with the given argument does not exist.
+     *
+     * @see [column]
+     * @see [ColumnsSelectionDsl.colGroup]
+     * @see [ColumnsSelectionDsl.frameCol]
+     * @see [ColumnsSelectionDsl.valueCol]
+     *
+     *
+     *
+     * @param [path] The path to the column.
+     * @param [C] The type of the column.
+     */
+    public fun <C> String.col(path: ColumnPath): ColumnAccessor<C> =
+        columnGroup(this).ensureIsColumnGroup().column(path)
+
+    /**
+     * ## Col
+     *
+     * Creates a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] (or [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]) for a column with the given argument which can be either
+     * an index ([Int]) or a reference to a column
+     * ([String], [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath], [KProperty], or [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor]; any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+     *
+     * This is a DSL-shorthand for [column][org.jetbrains.kotlinx.dataframe.api.column] and can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index).
+     * The function can also be called on [ColumnGroups][org.jetbrains.kotlinx.dataframe.ColumnGroupReference] to create
+     * an accessor for a column inside a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[col][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.col]`<`[String][String]`>("colA") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[col][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.col]`(SomeType::colB) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[col][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.col]`(1) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { Type::myColumnGroup.`[col][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.col]`("pathTo"["columnName"] ) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { Type::myColumnGroup.`[col][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.col]`<`[String][String]`>("pathTo"["columnName"] ) }`
+     *
+     * To create a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for a specific kind of column with runtime checks, take a look at the functions
+     * [valueCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.valueCol],
+     * [colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup],
+     * and [frameCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.frameCol].
+     *
+     * @return A [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for the column with the given argument if possible, else a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn].
+     * @throws [IllegalStateException] if the column with the given argument does not exist.
+     *
+     * @see [column]
+     * @see [ColumnsSelectionDsl.colGroup]
+     * @see [ColumnsSelectionDsl.frameCol]
+     * @see [ColumnsSelectionDsl.valueCol]
+     *
+     *
+     *
+     * @param [path] The path to the column.
+     */
+    @Suppress("INAPPLICABLE_JVM_NAME")
+    @JvmName("colUnTyped")
+    public fun KProperty<*>.col(path: ColumnPath): ColumnAccessor<*> = col<Any?>(path)
+
+    /**
+     * ## Col
+     *
+     * Creates a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] (or [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]) for a column with the given argument which can be either
+     * an index ([Int]) or a reference to a column
+     * ([String], [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath], [KProperty], or [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor]; any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+     *
+     * This is a DSL-shorthand for [column][org.jetbrains.kotlinx.dataframe.api.column] and can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index).
+     * The function can also be called on [ColumnGroups][org.jetbrains.kotlinx.dataframe.ColumnGroupReference] to create
+     * an accessor for a column inside a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[col][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.col]`<`[String][String]`>("colA") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[col][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.col]`(SomeType::colB) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[col][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.col]`(1) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { Type::myColumnGroup.`[col][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.col]`("pathTo"["columnName"] ) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { Type::myColumnGroup.`[col][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.col]`<`[String][String]`>("pathTo"["columnName"] ) }`
+     *
+     * To create a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for a specific kind of column with runtime checks, take a look at the functions
+     * [valueCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.valueCol],
+     * [colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup],
+     * and [frameCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.frameCol].
+     *
+     * @return A [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for the column with the given argument if possible, else a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn].
+     * @throws [IllegalStateException] if the column with the given argument does not exist.
+     *
+     * @see [column]
+     * @see [ColumnsSelectionDsl.colGroup]
+     * @see [ColumnsSelectionDsl.frameCol]
+     * @see [ColumnsSelectionDsl.valueCol]
+     *
+     *
+     *
+     * @param [path] The path to the column.
+     * @param [C] The type of the column.
+     */
+    public fun <C> KProperty<*>.col(path: ColumnPath): ColumnAccessor<C> =
+        columnGroup(this).ensureIsColumnGroup().column(path)
+
+    /**
+     * ## Col
+     *
+     * Creates a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] (or [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]) for a column with the given argument which can be either
+     * an index ([Int]) or a reference to a column
+     * ([String], [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath], [KProperty], or [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor]; any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+     *
+     * This is a DSL-shorthand for [column][org.jetbrains.kotlinx.dataframe.api.column] and can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index).
+     * The function can also be called on [ColumnGroups][org.jetbrains.kotlinx.dataframe.ColumnGroupReference] to create
+     * an accessor for a column inside a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[col][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.col]`<`[String][String]`>("colA") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[col][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.col]`(SomeType::colB) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[col][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.col]`(1) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "pathTo"["myColumnGroup"].`[col][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.col]`("pathTo"["columnName"] ) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "pathTo"["myColumnGroup"].`[col][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.col]`<`[String][String]`>("pathTo"["columnName"] ) }`
+     *
+     * To create a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for a specific kind of column with runtime checks, take a look at the functions
+     * [valueCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.valueCol],
+     * [colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup],
+     * and [frameCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.frameCol].
+     *
+     * @return A [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for the column with the given argument if possible, else a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn].
+     * @throws [IllegalStateException] if the column with the given argument does not exist.
+     *
+     * @see [column]
+     * @see [ColumnsSelectionDsl.colGroup]
+     * @see [ColumnsSelectionDsl.frameCol]
+     * @see [ColumnsSelectionDsl.valueCol]
+     *
+     *
+     *
+     * @param [path] The path to the column.
+     */
+    @Suppress("INAPPLICABLE_JVM_NAME")
+    @JvmName("colUnTyped")
+    public fun ColumnPath.col(path: ColumnPath): ColumnAccessor<*> = col<Any?>(path)
+
+    /**
+     * ## Col
+     *
+     * Creates a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] (or [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]) for a column with the given argument which can be either
+     * an index ([Int]) or a reference to a column
+     * ([String], [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath], [KProperty], or [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor]; any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+     *
+     * This is a DSL-shorthand for [column][org.jetbrains.kotlinx.dataframe.api.column] and can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index).
+     * The function can also be called on [ColumnGroups][org.jetbrains.kotlinx.dataframe.ColumnGroupReference] to create
+     * an accessor for a column inside a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[col][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.col]`<`[String][String]`>("colA") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[col][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.col]`(SomeType::colB) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[col][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.col]`(1) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "pathTo"["myColumnGroup"].`[col][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.col]`("pathTo"["columnName"] ) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "pathTo"["myColumnGroup"].`[col][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.col]`<`[String][String]`>("pathTo"["columnName"] ) }`
+     *
+     * To create a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for a specific kind of column with runtime checks, take a look at the functions
+     * [valueCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.valueCol],
+     * [colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup],
+     * and [frameCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.frameCol].
+     *
+     * @return A [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for the column with the given argument if possible, else a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn].
+     * @throws [IllegalStateException] if the column with the given argument does not exist.
+     *
+     * @see [column]
+     * @see [ColumnsSelectionDsl.colGroup]
+     * @see [ColumnsSelectionDsl.frameCol]
+     * @see [ColumnsSelectionDsl.valueCol]
+     *
+     *
+     *
+     * @param [path] The path to the column.
+     * @param [C] The type of the column.
+     */
+    public fun <C> ColumnPath.col(path: ColumnPath): ColumnAccessor<C> =
+        columnGroup(this).ensureIsColumnGroup().column(path)
+
+    // endregion
+
+    // region property
+
+    /**
+     * ## Col
+     *
+     * Creates a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] (or [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]) for a column with the given argument which can be either
+     * an index ([Int]) or a reference to a column
+     * ([String], [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath], [KProperty], or [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor]; any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+     *
+     * This is a DSL-shorthand for [column][org.jetbrains.kotlinx.dataframe.api.column] and can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index).
+     * The function can also be called on [ColumnGroups][org.jetbrains.kotlinx.dataframe.ColumnGroupReference] to create
+     * an accessor for a column inside a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[col][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.col]`<`[String][String]`>("colA") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[col][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.col]`(SomeType::colB) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[col][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.col]`(1) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { `[col][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.col]`(Type::columnA) }`
+     *
+     * To create a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for a specific kind of column with runtime checks, take a look at the functions
+     * [valueCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.valueCol],
+     * [colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup],
+     * and [frameCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.frameCol].
+     *
+     * @return A [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for the column with the given argument if possible, else a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn].
+     * @throws [IllegalStateException] if the column with the given argument does not exist.
+     *
+     * @see [column]
+     * @see [ColumnsSelectionDsl.colGroup]
+     * @see [ColumnsSelectionDsl.frameCol]
+     * @see [ColumnsSelectionDsl.valueCol]
+     *
+     *
+     *
+     * @param [property] The [KProperty] reference to the column.
+     * @param [C] The type of the column.
+     */
+    private interface ColKPropertyDocs
+
+    /**
+     * ## Col
+     *
+     * Creates a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] (or [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]) for a column with the given argument which can be either
+     * an index ([Int]) or a reference to a column
+     * ([String], [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath], [KProperty], or [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor]; any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+     *
+     * This is a DSL-shorthand for [column][org.jetbrains.kotlinx.dataframe.api.column] and can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index).
+     * The function can also be called on [ColumnGroups][org.jetbrains.kotlinx.dataframe.ColumnGroupReference] to create
+     * an accessor for a column inside a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[col][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.col]`<`[String][String]`>("colA") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[col][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.col]`(SomeType::colB) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[col][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.col]`(1) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { `[col][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.col]`(Type::columnA) }`
+     *
+     * To create a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for a specific kind of column with runtime checks, take a look at the functions
+     * [valueCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.valueCol],
+     * [colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup],
+     * and [frameCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.frameCol].
+     *
+     * @return A [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for the column with the given argument if possible, else a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn].
+     * @throws [IllegalStateException] if the column with the given argument does not exist.
+     *
+     * @see [column]
+     * @see [ColumnsSelectionDsl.colGroup]
+     * @see [ColumnsSelectionDsl.frameCol]
+     * @see [ColumnsSelectionDsl.valueCol]
+     *
+     *
+     *
+     * @param [property] The [KProperty] reference to the column.
+     * @param [C] The type of the column.
+     */
+    public fun <C> col(property: KProperty<C>): SingleColumn<C> = column(property)
+
+    /**
+     * ## Col
+     *
+     * Creates a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] (or [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]) for a column with the given argument which can be either
+     * an index ([Int]) or a reference to a column
+     * ([String], [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath], [KProperty], or [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor]; any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+     *
+     * This is a DSL-shorthand for [column][org.jetbrains.kotlinx.dataframe.api.column] and can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index).
+     * The function can also be called on [ColumnGroups][org.jetbrains.kotlinx.dataframe.ColumnGroupReference] to create
+     * an accessor for a column inside a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[col][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.col]`<`[String][String]`>("colA") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[col][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.col]`(SomeType::colB) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[col][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.col]`(1) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[col][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.col]`(Type::columnA) }`
+     *
+     * To create a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for a specific kind of column with runtime checks, take a look at the functions
+     * [valueCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.valueCol],
+     * [colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup],
+     * and [frameCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.frameCol].
+     *
+     * @return A [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for the column with the given argument if possible, else a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn].
+     * @throws [IllegalStateException] if the column with the given argument does not exist.
+     *
+     * @see [column]
+     * @see [ColumnsSelectionDsl.colGroup]
+     * @see [ColumnsSelectionDsl.frameCol]
+     * @see [ColumnsSelectionDsl.valueCol]
+     *
+     *
+     *
+     * @param [property] The [KProperty] reference to the column.
+     * @param [C] The type of the column.
+     */
+    public fun <C> SingleColumn<DataRow<*>>.col(property: KProperty<C>): SingleColumn<C> = col<C>(property.name)
+
+    /**
+     * ## Col
+     *
+     * Creates a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] (or [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]) for a column with the given argument which can be either
+     * an index ([Int]) or a reference to a column
+     * ([String], [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath], [KProperty], or [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor]; any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+     *
+     * This is a DSL-shorthand for [column][org.jetbrains.kotlinx.dataframe.api.column] and can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index).
+     * The function can also be called on [ColumnGroups][org.jetbrains.kotlinx.dataframe.ColumnGroupReference] to create
+     * an accessor for a column inside a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[col][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.col]`<`[String][String]`>("colA") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[col][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.col]`(SomeType::colB) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[col][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.col]`(1) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[col][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.col]`(Type::columnA) }`
+     *
+     * To create a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for a specific kind of column with runtime checks, take a look at the functions
+     * [valueCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.valueCol],
+     * [colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup],
+     * and [frameCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.frameCol].
+     *
+     * @return A [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for the column with the given argument if possible, else a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn].
+     * @throws [IllegalStateException] if the column with the given argument does not exist.
+     *
+     * @see [column]
+     * @see [ColumnsSelectionDsl.colGroup]
+     * @see [ColumnsSelectionDsl.frameCol]
+     * @see [ColumnsSelectionDsl.valueCol]
+     *
+     *
+     *
+     * @param [property] The [KProperty] reference to the column.
+     * @param [C] The type of the column.
+     */
+    public fun <C> AnyColumnGroupAccessor.col(property: KProperty<C>): ColumnAccessor<C> =
+        this.ensureIsColumnGroup().column(property)
+
+    /**
+     * ## Col
+     *
+     * Creates a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] (or [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]) for a column with the given argument which can be either
+     * an index ([Int]) or a reference to a column
+     * ([String], [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath], [KProperty], or [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor]; any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+     *
+     * This is a DSL-shorthand for [column][org.jetbrains.kotlinx.dataframe.api.column] and can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index).
+     * The function can also be called on [ColumnGroups][org.jetbrains.kotlinx.dataframe.ColumnGroupReference] to create
+     * an accessor for a column inside a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[col][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.col]`<`[String][String]`>("colA") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[col][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.col]`(SomeType::colB) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[col][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.col]`(1) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "myColumnGroup".`[col][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.col]`(Type::columnA) }`
+     *
+     * To create a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for a specific kind of column with runtime checks, take a look at the functions
+     * [valueCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.valueCol],
+     * [colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup],
+     * and [frameCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.frameCol].
+     *
+     * @return A [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for the column with the given argument if possible, else a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn].
+     * @throws [IllegalStateException] if the column with the given argument does not exist.
+     *
+     * @see [column]
+     * @see [ColumnsSelectionDsl.colGroup]
+     * @see [ColumnsSelectionDsl.frameCol]
+     * @see [ColumnsSelectionDsl.valueCol]
+     *
+     *
+     *
+     * @param [property] The [KProperty] reference to the column.
+     * @param [C] The type of the column.
+     */
+    public fun <C> String.col(property: KProperty<C>): ColumnAccessor<C> =
+        columnGroup(this).ensureIsColumnGroup().column(property)
+
+    /**
+     * ## Col
+     *
+     * Creates a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] (or [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]) for a column with the given argument which can be either
+     * an index ([Int]) or a reference to a column
+     * ([String], [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath], [KProperty], or [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor]; any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+     *
+     * This is a DSL-shorthand for [column][org.jetbrains.kotlinx.dataframe.api.column] and can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index).
+     * The function can also be called on [ColumnGroups][org.jetbrains.kotlinx.dataframe.ColumnGroupReference] to create
+     * an accessor for a column inside a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[col][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.col]`<`[String][String]`>("colA") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[col][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.col]`(SomeType::colB) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[col][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.col]`(1) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { Type::myColumnGroup.`[col][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.col]`(Type::columnA) }`
+     *
+     * To create a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for a specific kind of column with runtime checks, take a look at the functions
+     * [valueCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.valueCol],
+     * [colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup],
+     * and [frameCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.frameCol].
+     *
+     * @return A [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for the column with the given argument if possible, else a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn].
+     * @throws [IllegalStateException] if the column with the given argument does not exist.
+     *
+     * @see [column]
+     * @see [ColumnsSelectionDsl.colGroup]
+     * @see [ColumnsSelectionDsl.frameCol]
+     * @see [ColumnsSelectionDsl.valueCol]
+     *
+     *
+     *
+     * @param [property] The [KProperty] reference to the column.
+     * @param [C] The type of the column.
+     */
+    public fun <C> KProperty<*>.col(property: KProperty<C>): ColumnAccessor<C> =
+        columnGroup(this).ensureIsColumnGroup().column(property)
+
+    /**
+     * ## Col
+     *
+     * Creates a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] (or [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]) for a column with the given argument which can be either
+     * an index ([Int]) or a reference to a column
+     * ([String], [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath], [KProperty], or [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor]; any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+     *
+     * This is a DSL-shorthand for [column][org.jetbrains.kotlinx.dataframe.api.column] and can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index).
+     * The function can also be called on [ColumnGroups][org.jetbrains.kotlinx.dataframe.ColumnGroupReference] to create
+     * an accessor for a column inside a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[col][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.col]`<`[String][String]`>("colA") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[col][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.col]`(SomeType::colB) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[col][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.col]`(1) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "pathTo"["myColumnGroup"].`[col][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.col]`(Type::columnA) }`
+     *
+     * To create a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for a specific kind of column with runtime checks, take a look at the functions
+     * [valueCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.valueCol],
+     * [colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup],
+     * and [frameCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.frameCol].
+     *
+     * @return A [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for the column with the given argument if possible, else a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn].
+     * @throws [IllegalStateException] if the column with the given argument does not exist.
+     *
+     * @see [column]
+     * @see [ColumnsSelectionDsl.colGroup]
+     * @see [ColumnsSelectionDsl.frameCol]
+     * @see [ColumnsSelectionDsl.valueCol]
+     *
+     *
+     *
+     * @param [property] The [KProperty] reference to the column.
+     * @param [C] The type of the column.
+     */
+    public fun <C> ColumnPath.col(property: KProperty<C>): ColumnAccessor<C> =
+        columnGroup(this).ensureIsColumnGroup().column(property)
+
+    // endregion
+
+    // region index
+
+    /**
+     * ## Col
+     *
+     * Creates a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] (or [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]) for a column with the given argument which can be either
+     * an index ([Int]) or a reference to a column
+     * ([String], [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath], [KProperty], or [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor]; any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+     *
+     * This is a DSL-shorthand for [column][org.jetbrains.kotlinx.dataframe.api.column] and can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index).
+     * The function can also be called on [ColumnGroups][org.jetbrains.kotlinx.dataframe.ColumnGroupReference] to create
+     * an accessor for a column inside a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[col][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.col]`<`[String][String]`>("colA") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[col][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.col]`(SomeType::colB) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[col][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.col]`(1) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { `[col][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.col]`(0) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { `[col][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.col]`<`[String][String]`>(0) }`
+     *
+     * To create a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for a specific kind of column with runtime checks, take a look at the functions
+     * [valueCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.valueCol],
+     * [colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup],
+     * and [frameCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.frameCol].
+     *
+     * @return A [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for the column with the given argument if possible, else a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn].
+     * @throws [IllegalStateException] if the column with the given argument does not exist.
+     *
+     * @see [column]
+     * @see [ColumnsSelectionDsl.colGroup]
+     * @see [ColumnsSelectionDsl.frameCol]
+     * @see [ColumnsSelectionDsl.valueCol]
+     *
+     *
+     *
+     * @param [index] The index of the column.
+     * @throws [IndexOutOfBoundsException] if the index is out of bounds.
+     */
+    private interface ColIndexDocs
+
+    /**
+     * ## Col
+     *
+     * Creates a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] (or [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]) for a column with the given argument which can be either
+     * an index ([Int]) or a reference to a column
+     * ([String], [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath], [KProperty], or [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor]; any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+     *
+     * This is a DSL-shorthand for [column][org.jetbrains.kotlinx.dataframe.api.column] and can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index).
+     * The function can also be called on [ColumnGroups][org.jetbrains.kotlinx.dataframe.ColumnGroupReference] to create
+     * an accessor for a column inside a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * NOTE: You can use the get-[] operator on [ColumnSets][ColumnSet] as well!
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[col][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.col]`<`[String][String]`>("colA") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[col][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.col]`(SomeType::colB) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[col][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.col]`(1) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { `[colsOf][ColumnsSelectionDsl.colsOf]`<`[Int][Int]`>().`[col][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.col]`(0) }`
+     *
+     * `df.`[select][DataFrame.select]`  {  `[colsOf][ColumnsSelectionDsl.colsOf]`<`[String][String]`>()`[`[`][col]`1`[`]`][col]` }`
+     *
+     * To create a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for a specific kind of column with runtime checks, take a look at the functions
+     * [valueCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.valueCol],
+     * [colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup],
+     * and [frameCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.frameCol].
+     *
+     * @return A [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for the column with the given argument if possible, else a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn].
+     * @throws [IllegalStateException] if the column with the given argument does not exist.
+     *
+     * @see [column]
+     * @see [ColumnsSelectionDsl.colGroup]
+     * @see [ColumnsSelectionDsl.frameCol]
+     * @see [ColumnsSelectionDsl.valueCol]
+     *
+     *
+     *
+     * @param [index] The index of the column.
+     * @throws [IndexOutOfBoundsException] if the index is out of bounds.
+     * @param [C] The type of the column.
+     *
+     *
+     */
+    public fun <C> ColumnSet<C>.col(index: Int): SingleColumn<C> = getAt(index)
+
+    /**
+     * ## Col
+     *
+     * Creates a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] (or [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]) for a column with the given argument which can be either
+     * an index ([Int]) or a reference to a column
+     * ([String], [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath], [KProperty], or [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor]; any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+     *
+     * This is a DSL-shorthand for [column][org.jetbrains.kotlinx.dataframe.api.column] and can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index).
+     * The function can also be called on [ColumnGroups][org.jetbrains.kotlinx.dataframe.ColumnGroupReference] to create
+     * an accessor for a column inside a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[col][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.col]`<`[String][String]`>("colA") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[col][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.col]`(SomeType::colB) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[col][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.col]`(1) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { `[colsOf][ColumnsSelectionDsl.colsOf]`<`[Int][Int]`>().`[col][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.col]`(0) }`
+     *
+     * `df.`[select][DataFrame.select]`  {  `[colsOf][ColumnsSelectionDsl.colsOf]`<`[String][String]`>()`[`[`][col]`1`[`]`][col]` }`
+     *
+     * To create a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for a specific kind of column with runtime checks, take a look at the functions
+     * [valueCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.valueCol],
+     * [colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup],
+     * and [frameCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.frameCol].
+     *
+     * @return A [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for the column with the given argument if possible, else a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn].
+     * @throws [IllegalStateException] if the column with the given argument does not exist.
+     *
+     * @see [column]
+     * @see [ColumnsSelectionDsl.colGroup]
+     * @see [ColumnsSelectionDsl.frameCol]
+     * @see [ColumnsSelectionDsl.valueCol]
+     *
+     *
+     *
+     * @param [index] The index of the column.
+     * @throws [IndexOutOfBoundsException] if the index is out of bounds.
+     * @param [C] The type of the column.
+     *
+     */
+    public operator fun <C> ColumnSet<C>.get(index: Int): SingleColumn<C> = col(index)
+
+    /**
+     * ## Col
+     *
+     * Creates a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] (or [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]) for a column with the given argument which can be either
+     * an index ([Int]) or a reference to a column
+     * ([String], [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath], [KProperty], or [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor]; any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+     *
+     * This is a DSL-shorthand for [column][org.jetbrains.kotlinx.dataframe.api.column] and can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index).
+     * The function can also be called on [ColumnGroups][org.jetbrains.kotlinx.dataframe.ColumnGroupReference] to create
+     * an accessor for a column inside a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[col][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.col]`<`[String][String]`>("colA") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[col][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.col]`(SomeType::colB) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[col][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.col]`(1) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { `[col][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.col]`(0) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { `[col][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.col]`<`[String][String]`>(0) }`
+     *
+     * To create a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for a specific kind of column with runtime checks, take a look at the functions
+     * [valueCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.valueCol],
+     * [colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup],
+     * and [frameCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.frameCol].
+     *
+     * @return A [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for the column with the given argument if possible, else a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn].
+     * @throws [IllegalStateException] if the column with the given argument does not exist.
+     *
+     * @see [column]
+     * @see [ColumnsSelectionDsl.colGroup]
+     * @see [ColumnsSelectionDsl.frameCol]
+     * @see [ColumnsSelectionDsl.valueCol]
+     *
+     *
+     *
+     * @param [index] The index of the column.
+     * @throws [IndexOutOfBoundsException] if the index is out of bounds.
+     */
+    @Suppress("INAPPLICABLE_JVM_NAME")
+    @JvmName("colUnTyped")
+    public fun ColumnsSelectionDsl<*>.col(index: Int): SingleColumn<*> = col<Any?>(index)
+
+    /**
+     * ## Col
+     *
+     * Creates a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] (or [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]) for a column with the given argument which can be either
+     * an index ([Int]) or a reference to a column
+     * ([String], [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath], [KProperty], or [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor]; any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+     *
+     * This is a DSL-shorthand for [column][org.jetbrains.kotlinx.dataframe.api.column] and can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index).
+     * The function can also be called on [ColumnGroups][org.jetbrains.kotlinx.dataframe.ColumnGroupReference] to create
+     * an accessor for a column inside a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[col][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.col]`<`[String][String]`>("colA") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[col][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.col]`(SomeType::colB) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[col][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.col]`(1) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { `[col][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.col]`(0) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { `[col][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.col]`<`[String][String]`>(0) }`
+     *
+     * To create a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for a specific kind of column with runtime checks, take a look at the functions
+     * [valueCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.valueCol],
+     * [colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup],
+     * and [frameCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.frameCol].
+     *
+     * @return A [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for the column with the given argument if possible, else a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn].
+     * @throws [IllegalStateException] if the column with the given argument does not exist.
+     *
+     * @see [column]
+     * @see [ColumnsSelectionDsl.colGroup]
+     * @see [ColumnsSelectionDsl.frameCol]
+     * @see [ColumnsSelectionDsl.valueCol]
+     *
+     *
+     *
+     * @param [index] The index of the column.
+     * @throws [IndexOutOfBoundsException] if the index is out of bounds.
+     * @param [C] The type of the column.
+     */
+    public fun <C> ColumnsSelectionDsl<*>.col(index: Int): SingleColumn<C> = asSingleColumn().col<C>(index)
+
+    /**
+     * ## Col
+     *
+     * Creates a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] (or [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]) for a column with the given argument which can be either
+     * an index ([Int]) or a reference to a column
+     * ([String], [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath], [KProperty], or [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor]; any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+     *
+     * This is a DSL-shorthand for [column][org.jetbrains.kotlinx.dataframe.api.column] and can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index).
+     * The function can also be called on [ColumnGroups][org.jetbrains.kotlinx.dataframe.ColumnGroupReference] to create
+     * an accessor for a column inside a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[col][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.col]`<`[String][String]`>("colA") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[col][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.col]`(SomeType::colB) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[col][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.col]`(1) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[col][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.col]`(0) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[col][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.col]`<`[String][String]`>(0) }`
+     *
+     * To create a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for a specific kind of column with runtime checks, take a look at the functions
+     * [valueCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.valueCol],
+     * [colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup],
+     * and [frameCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.frameCol].
+     *
+     * @return A [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for the column with the given argument if possible, else a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn].
+     * @throws [IllegalStateException] if the column with the given argument does not exist.
+     *
+     * @see [column]
+     * @see [ColumnsSelectionDsl.colGroup]
+     * @see [ColumnsSelectionDsl.frameCol]
+     * @see [ColumnsSelectionDsl.valueCol]
+     *
+     *
+     *
+     * @param [index] The index of the column.
+     * @throws [IndexOutOfBoundsException] if the index is out of bounds.
+     */
+    @Suppress("INAPPLICABLE_JVM_NAME")
+    @JvmName("colUnTyped")
+    public fun SingleColumn<DataRow<*>>.col(index: Int): SingleColumn<*> = col<Any?>(index)
+
+    /**
+     * ## Col
+     *
+     * Creates a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] (or [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]) for a column with the given argument which can be either
+     * an index ([Int]) or a reference to a column
+     * ([String], [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath], [KProperty], or [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor]; any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+     *
+     * This is a DSL-shorthand for [column][org.jetbrains.kotlinx.dataframe.api.column] and can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index).
+     * The function can also be called on [ColumnGroups][org.jetbrains.kotlinx.dataframe.ColumnGroupReference] to create
+     * an accessor for a column inside a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[col][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.col]`<`[String][String]`>("colA") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[col][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.col]`(SomeType::colB) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[col][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.col]`(1) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[col][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.col]`(0) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[col][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.col]`<`[String][String]`>(0) }`
+     *
+     * To create a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for a specific kind of column with runtime checks, take a look at the functions
+     * [valueCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.valueCol],
+     * [colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup],
+     * and [frameCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.frameCol].
+     *
+     * @return A [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for the column with the given argument if possible, else a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn].
+     * @throws [IllegalStateException] if the column with the given argument does not exist.
+     *
+     * @see [column]
+     * @see [ColumnsSelectionDsl.colGroup]
+     * @see [ColumnsSelectionDsl.frameCol]
+     * @see [ColumnsSelectionDsl.valueCol]
+     *
+     *
+     *
+     * @param [index] The index of the column.
+     * @throws [IndexOutOfBoundsException] if the index is out of bounds.
+     * @param [C] The type of the column.
+     */
+    public fun <C> SingleColumn<DataRow<*>>.col(index: Int): SingleColumn<C> =
+        this.ensureIsColumnGroup()
+            .allColumnsInternal()
+            .getAt(index)
+            .cast()
+
+    /**
+     * ## Col
+     *
+     * Creates a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] (or [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]) for a column with the given argument which can be either
+     * an index ([Int]) or a reference to a column
+     * ([String], [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath], [KProperty], or [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor]; any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+     *
+     * This is a DSL-shorthand for [column][org.jetbrains.kotlinx.dataframe.api.column] and can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index).
+     * The function can also be called on [ColumnGroups][org.jetbrains.kotlinx.dataframe.ColumnGroupReference] to create
+     * an accessor for a column inside a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[col][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.col]`<`[String][String]`>("colA") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[col][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.col]`(SomeType::colB) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[col][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.col]`(1) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "myColumnGroup".`[col][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.col]`(0) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "myColumnGroup".`[col][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.col]`<`[String][String]`>(0) }`
+     *
+     * To create a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for a specific kind of column with runtime checks, take a look at the functions
+     * [valueCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.valueCol],
+     * [colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup],
+     * and [frameCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.frameCol].
+     *
+     * @return A [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for the column with the given argument if possible, else a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn].
+     * @throws [IllegalStateException] if the column with the given argument does not exist.
+     *
+     * @see [column]
+     * @see [ColumnsSelectionDsl.colGroup]
+     * @see [ColumnsSelectionDsl.frameCol]
+     * @see [ColumnsSelectionDsl.valueCol]
+     *
+     *
+     *
+     * @param [index] The index of the column.
+     * @throws [IndexOutOfBoundsException] if the index is out of bounds.
+     */
+    @Suppress("INAPPLICABLE_JVM_NAME")
+    @JvmName("colUnTyped")
+    public fun String.col(index: Int): SingleColumn<*> = col<Any?>(index)
+
+    /**
+     * ## Col
+     *
+     * Creates a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] (or [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]) for a column with the given argument which can be either
+     * an index ([Int]) or a reference to a column
+     * ([String], [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath], [KProperty], or [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor]; any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+     *
+     * This is a DSL-shorthand for [column][org.jetbrains.kotlinx.dataframe.api.column] and can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index).
+     * The function can also be called on [ColumnGroups][org.jetbrains.kotlinx.dataframe.ColumnGroupReference] to create
+     * an accessor for a column inside a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[col][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.col]`<`[String][String]`>("colA") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[col][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.col]`(SomeType::colB) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[col][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.col]`(1) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "myColumnGroup".`[col][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.col]`(0) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "myColumnGroup".`[col][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.col]`<`[String][String]`>(0) }`
+     *
+     * To create a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for a specific kind of column with runtime checks, take a look at the functions
+     * [valueCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.valueCol],
+     * [colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup],
+     * and [frameCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.frameCol].
+     *
+     * @return A [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for the column with the given argument if possible, else a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn].
+     * @throws [IllegalStateException] if the column with the given argument does not exist.
+     *
+     * @see [column]
+     * @see [ColumnsSelectionDsl.colGroup]
+     * @see [ColumnsSelectionDsl.frameCol]
+     * @see [ColumnsSelectionDsl.valueCol]
+     *
+     *
+     *
+     * @param [index] The index of the column.
+     * @throws [IndexOutOfBoundsException] if the index is out of bounds.
+     * @param [C] The type of the column.
+     */
+    public fun <C> String.col(index: Int): SingleColumn<C> = columnGroup(this).col<C>(index)
+
+    /**
+     * ## Col
+     *
+     * Creates a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] (or [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]) for a column with the given argument which can be either
+     * an index ([Int]) or a reference to a column
+     * ([String], [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath], [KProperty], or [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor]; any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+     *
+     * This is a DSL-shorthand for [column][org.jetbrains.kotlinx.dataframe.api.column] and can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index).
+     * The function can also be called on [ColumnGroups][org.jetbrains.kotlinx.dataframe.ColumnGroupReference] to create
+     * an accessor for a column inside a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[col][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.col]`<`[String][String]`>("colA") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[col][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.col]`(SomeType::colB) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[col][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.col]`(1) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { Type::myColumnGroup.`[col][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.col]`(0) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { Type::myColumnGroup.`[col][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.col]`<`[String][String]`>(0) }`
+     *
+     * To create a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for a specific kind of column with runtime checks, take a look at the functions
+     * [valueCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.valueCol],
+     * [colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup],
+     * and [frameCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.frameCol].
+     *
+     * @return A [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for the column with the given argument if possible, else a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn].
+     * @throws [IllegalStateException] if the column with the given argument does not exist.
+     *
+     * @see [column]
+     * @see [ColumnsSelectionDsl.colGroup]
+     * @see [ColumnsSelectionDsl.frameCol]
+     * @see [ColumnsSelectionDsl.valueCol]
+     *
+     *
+     *
+     * @param [index] The index of the column.
+     * @throws [IndexOutOfBoundsException] if the index is out of bounds.
+     */
+    @Suppress("INAPPLICABLE_JVM_NAME")
+    @JvmName("colUnTyped")
+    public fun KProperty<*>.col(index: Int): SingleColumn<*> = col<Any?>(index)
+
+    /**
+     * ## Col
+     *
+     * Creates a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] (or [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]) for a column with the given argument which can be either
+     * an index ([Int]) or a reference to a column
+     * ([String], [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath], [KProperty], or [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor]; any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+     *
+     * This is a DSL-shorthand for [column][org.jetbrains.kotlinx.dataframe.api.column] and can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index).
+     * The function can also be called on [ColumnGroups][org.jetbrains.kotlinx.dataframe.ColumnGroupReference] to create
+     * an accessor for a column inside a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[col][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.col]`<`[String][String]`>("colA") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[col][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.col]`(SomeType::colB) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[col][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.col]`(1) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { Type::myColumnGroup.`[col][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.col]`(0) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { Type::myColumnGroup.`[col][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.col]`<`[String][String]`>(0) }`
+     *
+     * To create a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for a specific kind of column with runtime checks, take a look at the functions
+     * [valueCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.valueCol],
+     * [colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup],
+     * and [frameCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.frameCol].
+     *
+     * @return A [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for the column with the given argument if possible, else a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn].
+     * @throws [IllegalStateException] if the column with the given argument does not exist.
+     *
+     * @see [column]
+     * @see [ColumnsSelectionDsl.colGroup]
+     * @see [ColumnsSelectionDsl.frameCol]
+     * @see [ColumnsSelectionDsl.valueCol]
+     *
+     *
+     *
+     * @param [index] The index of the column.
+     * @throws [IndexOutOfBoundsException] if the index is out of bounds.
+     * @param [C] The type of the column.
+     */
+    public fun <C> KProperty<*>.col(index: Int): SingleColumn<C> = columnGroup(this).col<C>(index)
+
+    /**
+     * ## Col
+     *
+     * Creates a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] (or [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]) for a column with the given argument which can be either
+     * an index ([Int]) or a reference to a column
+     * ([String], [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath], [KProperty], or [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor]; any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+     *
+     * This is a DSL-shorthand for [column][org.jetbrains.kotlinx.dataframe.api.column] and can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index).
+     * The function can also be called on [ColumnGroups][org.jetbrains.kotlinx.dataframe.ColumnGroupReference] to create
+     * an accessor for a column inside a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[col][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.col]`<`[String][String]`>("colA") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[col][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.col]`(SomeType::colB) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[col][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.col]`(1) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "pathTo"["myColumnGroup"].`[col][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.col]`(0) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "pathTo"["myColumnGroup"].`[col][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.col]`<`[String][String]`>(0) }`
+     *
+     * To create a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for a specific kind of column with runtime checks, take a look at the functions
+     * [valueCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.valueCol],
+     * [colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup],
+     * and [frameCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.frameCol].
+     *
+     * @return A [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for the column with the given argument if possible, else a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn].
+     * @throws [IllegalStateException] if the column with the given argument does not exist.
+     *
+     * @see [column]
+     * @see [ColumnsSelectionDsl.colGroup]
+     * @see [ColumnsSelectionDsl.frameCol]
+     * @see [ColumnsSelectionDsl.valueCol]
+     *
+     *
+     *
+     * @param [index] The index of the column.
+     * @throws [IndexOutOfBoundsException] if the index is out of bounds.
+     */
+    @Suppress("INAPPLICABLE_JVM_NAME")
+    @JvmName("colUnTyped")
+    public fun ColumnPath.col(index: Int): SingleColumn<*> = col<Any?>(index)
+
+    /**
+     * ## Col
+     *
+     * Creates a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] (or [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]) for a column with the given argument which can be either
+     * an index ([Int]) or a reference to a column
+     * ([String], [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath], [KProperty], or [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor]; any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+     *
+     * This is a DSL-shorthand for [column][org.jetbrains.kotlinx.dataframe.api.column] and can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index).
+     * The function can also be called on [ColumnGroups][org.jetbrains.kotlinx.dataframe.ColumnGroupReference] to create
+     * an accessor for a column inside a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[col][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.col]`<`[String][String]`>("colA") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[col][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.col]`(SomeType::colB) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[col][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.col]`(1) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "pathTo"["myColumnGroup"].`[col][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.col]`(0) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "pathTo"["myColumnGroup"].`[col][org.jetbrains.kotlinx.dataframe.api.ColColumnsSelectionDsl.col]`<`[String][String]`>(0) }`
+     *
+     * To create a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for a specific kind of column with runtime checks, take a look at the functions
+     * [valueCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.valueCol],
+     * [colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup],
+     * and [frameCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.frameCol].
+     *
+     * @return A [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for the column with the given argument if possible, else a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn].
+     * @throws [IllegalStateException] if the column with the given argument does not exist.
+     *
+     * @see [column]
+     * @see [ColumnsSelectionDsl.colGroup]
+     * @see [ColumnsSelectionDsl.frameCol]
+     * @see [ColumnsSelectionDsl.valueCol]
+     *
+     *
+     *
+     * @param [index] The index of the column.
+     * @throws [IndexOutOfBoundsException] if the index is out of bounds.
+     * @param [C] The type of the column.
+     */
+    public fun <C> ColumnPath.col(index: Int): SingleColumn<C> = columnGroup(this).col<C>(index)
+
+    // endregion
+}
+
+// endregion
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/colGroup.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/colGroup.kt
new file mode 100644
index 000000000..da08ed0b4
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/colGroup.kt
@@ -0,0 +1,3473 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import org.jetbrains.kotlinx.dataframe.AnyColumnGroupAccessor
+import org.jetbrains.kotlinx.dataframe.ColumnGroupReference
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.DataRow
+import org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.Grammar
+import org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor
+import org.jetbrains.kotlinx.dataframe.columns.ColumnGroup
+import org.jetbrains.kotlinx.dataframe.columns.ColumnPath
+import org.jetbrains.kotlinx.dataframe.columns.ColumnSet
+import org.jetbrains.kotlinx.dataframe.columns.ColumnWithPath
+import org.jetbrains.kotlinx.dataframe.columns.SingleColumn
+import org.jetbrains.kotlinx.dataframe.impl.columns.getAt
+import org.jetbrains.kotlinx.dataframe.impl.columns.onResolve
+import org.jetbrains.kotlinx.dataframe.impl.columns.singleImpl
+import org.jetbrains.kotlinx.dataframe.impl.columns.transformSingle
+import kotlin.reflect.KProperty
+
+// region ColumnsSelectionDsl
+
+/**
+ * ## Column Group [Columns Selection DSL][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl]
+ *
+ * See [Grammar] for all functions in this interface.
+ * @param _UNUSED [#KT-68546](https://youtrack.jetbrains.com/issue/KT-68546/Conflicting-overloads-in-non-generic-interface-K2-2.0.0)
+ */
+public interface ColGroupColumnsSelectionDsl<out _UNUSED> {
+
+    /**
+     * ## Col Group Grammar
+     *
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * [(What is this notation?)][org.jetbrains.kotlinx.dataframe.documentation.DslGrammar]
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  ### Definitions:
+     *  `columnSet: `[`ColumnSet`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]`<*>`
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  `columnGroup: `[`SingleColumn`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]`<`[`DataRow`][org.jetbrains.kotlinx.dataframe.DataRow]`<*>> | `[`String`][String]`  |  `[`KProperty`][kotlin.reflect.KProperty]`<* | `[`DataRow`][org.jetbrains.kotlinx.dataframe.DataRow]`<*>> | `[`ColumnPath`][org.jetbrains.kotlinx.dataframe.columns.ColumnPath]
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  `column: `[`ColumnAccessor`][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor]`  |  `[`String`][String]`  | `[`KProperty`][kotlin.reflect.KProperty]`<*> | `[`ColumnPath`][org.jetbrains.kotlinx.dataframe.columns.ColumnPath]
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  `index: `[`Int`][Int]
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  `T: Column type`
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  ### What can be called directly in the [Columns Selection DSL][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl]:
+     *
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  [**`colGroup`**][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup]`[`**`<`**[`T`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ColumnTypeDef]**`>`**`]`**`(`**[`column`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ColumnDef]`  |  `[`index`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.IndexDef]**`)`**
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  ### What can be called on a [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]:
+     *
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  [`columnSet`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ColumnSetDef]
+     *
+     *  &nbsp;&nbsp;&nbsp;&nbsp;__`.`__[**`colGroup`**][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup]**`(`**[`index`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.IndexDef]**`)`**
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  ### What can be called on a [Column Group (reference)][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ColumnGroupDef]:
+     *
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  [`columnGroup`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ColumnGroupDef]
+     *
+     *  &nbsp;&nbsp;&nbsp;&nbsp;__`.`__[**`colGroup`**][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup]`[`**`<`**[`T`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ColumnTypeDef]**`>`**`]`**`(`**[`column`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ColumnDef]`  |  `[`index`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.IndexDef]**`)`**
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     */
+    public interface Grammar {
+
+        /** [**`colGroup`**][ColumnsSelectionDsl.colGroup] */
+        public interface PlainDslName
+
+        /** __`.`__[**`colGroup`**][ColumnsSelectionDsl.colGroup] */
+        public interface ColumnSetName
+
+        /** __`.`__[**`colGroup`**][ColumnsSelectionDsl.colGroup] */
+        public interface ColumnGroupName
+    }
+
+    /**
+     * ## Col Group
+     *
+     * Creates a [ColumnAccessor] (or [SingleColumn]) for a column group with the given argument which can be either
+     * an index ([Int]) or a reference to a column
+     * ([String], [ColumnPath], [KProperty], or [ColumnAccessor]; any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+     *
+     * This is a DSL-shorthand for [columnGroup] and can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index). In addition, extra runtime checks are in place to ensure that the column
+     * you specify is actually a column group.
+     * The function can also be called on [ColumnGroups][ColumnGroupReference] to create
+     * an accessor for a column group inside a [ColumnGroup].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     *
+     * ### Check out: [Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][DataFrame.select]`  {  `[colGroup][colGroup]`<`[String][String]`>("colGroupA") }`
+     *
+     * `df.`[select][DataFrame.select]`  {  `[colGroup][colGroup]`(SomeType::colGroupB) }`
+     *
+     * `df.`[select][DataFrame.select]` { myColumnGroup.`[colGroup][colGroup]`(1) }`
+     *
+     * #### Examples for this overload:
+     *
+     *
+     *
+     * To create a [ColumnAccessor] for another kind of column, take a look at the functions
+     * [col][ColumnsSelectionDsl.col],
+     * [valueCol][ColumnsSelectionDsl.valueCol],
+     * and [frameCol][ColumnsSelectionDsl.frameCol].
+     *
+     * @return A [ColumnAccessor] for the column group with the given argument if possible, else a [SingleColumn].
+     * @throws [IllegalStateException] if the column with the given argument does not exist.
+     * @throws [IllegalArgumentException] if the column with the given argument is not a column group.
+     *
+     * @see [columnGroup]
+     * @see [ColumnsSelectionDsl.frameCol]
+     * @see [ColumnsSelectionDsl.valueCol]
+     * @see [ColumnsSelectionDsl.col]
+     *
+     */
+    private interface CommonColGroupDocs {
+
+        // Example argument, can be either {@include [SingleExample]} or {@include [DoubleExample]}
+        interface ExampleArg
+
+        /**
+         * `df.`[select][DataFrame.select]` { `[colGroup][colGroup]`() }`
+         */
+        interface SingleExample
+
+        /**
+         * `df.`[select][DataFrame.select]` { `[colGroup][colGroup]`() }`
+         *
+         * `df.`[select][DataFrame.select]` { `[colGroup][colGroup]`<`[String][String]`>() }`
+         */
+        interface DoubleExample
+
+        // Receiver argument for the example(s)
+        interface ReceiverArg
+
+        // Argument for the example(s)
+        interface Arg
+
+        // Optional note
+        interface Note
+
+        /** @param [C] The type of the column group. */
+        interface ColumnGroupTypeParam
+    }
+
+    // region reference
+
+    /**
+     * ## Col Group
+     *
+     * Creates a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] (or [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]) for a column group with the given argument which can be either
+     * an index ([Int]) or a reference to a column
+     * ([String], [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath], [KProperty], or [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor]; any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+     *
+     * This is a DSL-shorthand for [columnGroup][org.jetbrains.kotlinx.dataframe.api.columnGroup] and can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index). In addition, extra runtime checks are in place to ensure that the column
+     * you specify is actually a column group.
+     * The function can also be called on [ColumnGroups][org.jetbrains.kotlinx.dataframe.ColumnGroupReference] to create
+     * an accessor for a column group inside a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`<`[String][String]`>("colGroupA") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`(SomeType::colGroupB) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`(1) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`(columnGroupA) }`
+     *
+     * To create a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for another kind of column, take a look at the functions
+     * [col][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.col],
+     * [valueCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.valueCol],
+     * and [frameCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.frameCol].
+     *
+     * @return A [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for the column group with the given argument if possible, else a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn].
+     * @throws [IllegalStateException] if the column with the given argument does not exist.
+     * @throws [IllegalArgumentException] if the column with the given argument is not a column group.
+     *
+     * @see [columnGroup]
+     * @see [ColumnsSelectionDsl.frameCol]
+     * @see [ColumnsSelectionDsl.valueCol]
+     * @see [ColumnsSelectionDsl.col]
+     *
+     *
+     *
+     * @param [col] The [ColumnAccessor] pointing to the value column.
+     * @param [C] The type of the column group.
+     */
+    private interface ColGroupReferenceDocs
+
+    /**
+     * ## Col Group
+     *
+     * Creates a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] (or [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]) for a column group with the given argument which can be either
+     * an index ([Int]) or a reference to a column
+     * ([String], [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath], [KProperty], or [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor]; any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+     *
+     * This is a DSL-shorthand for [columnGroup][org.jetbrains.kotlinx.dataframe.api.columnGroup] and can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index). In addition, extra runtime checks are in place to ensure that the column
+     * you specify is actually a column group.
+     * The function can also be called on [ColumnGroups][org.jetbrains.kotlinx.dataframe.ColumnGroupReference] to create
+     * an accessor for a column group inside a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`<`[String][String]`>("colGroupA") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`(SomeType::colGroupB) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`(1) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`(columnGroupA) }`
+     *
+     * To create a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for another kind of column, take a look at the functions
+     * [col][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.col],
+     * [valueCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.valueCol],
+     * and [frameCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.frameCol].
+     *
+     * @return A [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for the column group with the given argument if possible, else a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn].
+     * @throws [IllegalStateException] if the column with the given argument does not exist.
+     * @throws [IllegalArgumentException] if the column with the given argument is not a column group.
+     *
+     * @see [columnGroup]
+     * @see [ColumnsSelectionDsl.frameCol]
+     * @see [ColumnsSelectionDsl.valueCol]
+     * @see [ColumnsSelectionDsl.col]
+     *
+     *
+     *
+     * @param [col] The [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] pointing to the value column.
+     * @param [C] The type of the column group.
+     */
+    public fun <C> colGroup(colGroup: ColumnAccessor<DataRow<C>>): ColumnAccessor<DataRow<C>> =
+        colGroup.ensureIsColumnGroup()
+
+    /**
+     * ## Col Group
+     *
+     * Creates a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] (or [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]) for a column group with the given argument which can be either
+     * an index ([Int]) or a reference to a column
+     * ([String], [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath], [KProperty], or [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor]; any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+     *
+     * This is a DSL-shorthand for [columnGroup][org.jetbrains.kotlinx.dataframe.api.columnGroup] and can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index). In addition, extra runtime checks are in place to ensure that the column
+     * you specify is actually a column group.
+     * The function can also be called on [ColumnGroups][org.jetbrains.kotlinx.dataframe.ColumnGroupReference] to create
+     * an accessor for a column group inside a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`<`[String][String]`>("colGroupA") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`(SomeType::colGroupB) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`(1) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`(columnGroupA) }`
+     *
+     * To create a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for another kind of column, take a look at the functions
+     * [col][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.col],
+     * [valueCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.valueCol],
+     * and [frameCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.frameCol].
+     *
+     * @return A [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for the column group with the given argument if possible, else a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn].
+     * @throws [IllegalStateException] if the column with the given argument does not exist.
+     * @throws [IllegalArgumentException] if the column with the given argument is not a column group.
+     *
+     * @see [columnGroup]
+     * @see [ColumnsSelectionDsl.frameCol]
+     * @see [ColumnsSelectionDsl.valueCol]
+     * @see [ColumnsSelectionDsl.col]
+     *
+     *
+     *
+     * @param [col] The [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] pointing to the value column.
+     * @param [C] The type of the column group.
+     */
+    public fun <C> SingleColumn<DataRow<*>>.colGroup(colGroup: ColumnAccessor<DataRow<C>>): SingleColumn<DataRow<C>> =
+        this.ensureIsColumnGroup().transformSingle {
+            val child = it.getCol(colGroup)
+                ?: throw IllegalStateException(
+                    "ColumnGroup '${colGroup.path()}' not found in column group '${it.path}'",
+                )
+            child.data.ensureIsColumnGroup()
+            listOf(child)
+        }.singleImpl()
+
+    /**
+     * ## Col Group
+     *
+     * Creates a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] (or [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]) for a column group with the given argument which can be either
+     * an index ([Int]) or a reference to a column
+     * ([String], [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath], [KProperty], or [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor]; any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+     *
+     * This is a DSL-shorthand for [columnGroup][org.jetbrains.kotlinx.dataframe.api.columnGroup] and can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index). In addition, extra runtime checks are in place to ensure that the column
+     * you specify is actually a column group.
+     * The function can also be called on [ColumnGroups][org.jetbrains.kotlinx.dataframe.ColumnGroupReference] to create
+     * an accessor for a column group inside a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`<`[String][String]`>("colGroupA") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`(SomeType::colGroupB) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`(1) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`(columnGroupA) }`
+     *
+     * To create a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for another kind of column, take a look at the functions
+     * [col][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.col],
+     * [valueCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.valueCol],
+     * and [frameCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.frameCol].
+     *
+     * @return A [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for the column group with the given argument if possible, else a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn].
+     * @throws [IllegalStateException] if the column with the given argument does not exist.
+     * @throws [IllegalArgumentException] if the column with the given argument is not a column group.
+     *
+     * @see [columnGroup]
+     * @see [ColumnsSelectionDsl.frameCol]
+     * @see [ColumnsSelectionDsl.valueCol]
+     * @see [ColumnsSelectionDsl.col]
+     *
+     *
+     *
+     * @param [col] The [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] pointing to the value column.
+     * @param [C] The type of the column group.
+     */
+    public fun <C> AnyColumnGroupAccessor.colGroup(colGroup: ColumnAccessor<DataRow<C>>): ColumnAccessor<DataRow<C>> =
+        this.ensureIsColumnGroup().columnGroup<C>(colGroup.path()).ensureIsColumnGroup()
+
+    /**
+     * ## Col Group
+     *
+     * Creates a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] (or [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]) for a column group with the given argument which can be either
+     * an index ([Int]) or a reference to a column
+     * ([String], [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath], [KProperty], or [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor]; any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+     *
+     * This is a DSL-shorthand for [columnGroup][org.jetbrains.kotlinx.dataframe.api.columnGroup] and can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index). In addition, extra runtime checks are in place to ensure that the column
+     * you specify is actually a column group.
+     * The function can also be called on [ColumnGroups][org.jetbrains.kotlinx.dataframe.ColumnGroupReference] to create
+     * an accessor for a column group inside a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`<`[String][String]`>("colGroupA") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`(SomeType::colGroupB) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`(1) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "myColumnGroup".`[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`(columnGroupA) }`
+     *
+     * To create a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for another kind of column, take a look at the functions
+     * [col][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.col],
+     * [valueCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.valueCol],
+     * and [frameCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.frameCol].
+     *
+     * @return A [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for the column group with the given argument if possible, else a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn].
+     * @throws [IllegalStateException] if the column with the given argument does not exist.
+     * @throws [IllegalArgumentException] if the column with the given argument is not a column group.
+     *
+     * @see [columnGroup]
+     * @see [ColumnsSelectionDsl.frameCol]
+     * @see [ColumnsSelectionDsl.valueCol]
+     * @see [ColumnsSelectionDsl.col]
+     *
+     *
+     *
+     * @param [col] The [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] pointing to the value column.
+     * @param [C] The type of the column group.
+     */
+    public fun <C> String.colGroup(colGroup: ColumnAccessor<DataRow<C>>): ColumnAccessor<DataRow<C>> =
+        columnGroup(this).ensureIsColumnGroup().columnGroup<C>(colGroup.path()).ensureIsColumnGroup()
+
+    /**
+     * ## Col Group
+     *
+     * Creates a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] (or [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]) for a column group with the given argument which can be either
+     * an index ([Int]) or a reference to a column
+     * ([String], [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath], [KProperty], or [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor]; any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+     *
+     * This is a DSL-shorthand for [columnGroup][org.jetbrains.kotlinx.dataframe.api.columnGroup] and can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index). In addition, extra runtime checks are in place to ensure that the column
+     * you specify is actually a column group.
+     * The function can also be called on [ColumnGroups][org.jetbrains.kotlinx.dataframe.ColumnGroupReference] to create
+     * an accessor for a column group inside a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`<`[String][String]`>("colGroupA") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`(SomeType::colGroupB) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`(1) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { Type::myColumnGroup.`[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`(columnGroupA) }`
+     *
+     * To create a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for another kind of column, take a look at the functions
+     * [col][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.col],
+     * [valueCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.valueCol],
+     * and [frameCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.frameCol].
+     *
+     * @return A [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for the column group with the given argument if possible, else a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn].
+     * @throws [IllegalStateException] if the column with the given argument does not exist.
+     * @throws [IllegalArgumentException] if the column with the given argument is not a column group.
+     *
+     * @see [columnGroup]
+     * @see [ColumnsSelectionDsl.frameCol]
+     * @see [ColumnsSelectionDsl.valueCol]
+     * @see [ColumnsSelectionDsl.col]
+     *
+     *
+     *
+     * @param [col] The [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] pointing to the value column.
+     * @param [C] The type of the column group.
+     */
+    public fun <C> KProperty<*>.colGroup(colGroup: ColumnAccessor<DataRow<C>>): ColumnAccessor<DataRow<C>> =
+        columnGroup(this).ensureIsColumnGroup().columnGroup<C>(colGroup.path()).ensureIsColumnGroup()
+
+    /**
+     * ## Col Group
+     *
+     * Creates a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] (or [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]) for a column group with the given argument which can be either
+     * an index ([Int]) or a reference to a column
+     * ([String], [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath], [KProperty], or [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor]; any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+     *
+     * This is a DSL-shorthand for [columnGroup][org.jetbrains.kotlinx.dataframe.api.columnGroup] and can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index). In addition, extra runtime checks are in place to ensure that the column
+     * you specify is actually a column group.
+     * The function can also be called on [ColumnGroups][org.jetbrains.kotlinx.dataframe.ColumnGroupReference] to create
+     * an accessor for a column group inside a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`<`[String][String]`>("colGroupA") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`(SomeType::colGroupB) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`(1) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "pathTo"["myColumnGroup"].`[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`(columnGroupA) }`
+     *
+     * To create a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for another kind of column, take a look at the functions
+     * [col][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.col],
+     * [valueCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.valueCol],
+     * and [frameCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.frameCol].
+     *
+     * @return A [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for the column group with the given argument if possible, else a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn].
+     * @throws [IllegalStateException] if the column with the given argument does not exist.
+     * @throws [IllegalArgumentException] if the column with the given argument is not a column group.
+     *
+     * @see [columnGroup]
+     * @see [ColumnsSelectionDsl.frameCol]
+     * @see [ColumnsSelectionDsl.valueCol]
+     * @see [ColumnsSelectionDsl.col]
+     *
+     *
+     *
+     * @param [col] The [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] pointing to the value column.
+     * @param [C] The type of the column group.
+     */
+    public fun <C> ColumnPath.colGroup(colGroup: ColumnAccessor<DataRow<C>>): ColumnAccessor<DataRow<C>> =
+        columnGroup(this).ensureIsColumnGroup().columnGroup<C>(colGroup.path()).ensureIsColumnGroup()
+
+    // endregion
+
+    // region name
+
+    /**
+     * ## Col Group
+     *
+     * Creates a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] (or [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]) for a column group with the given argument which can be either
+     * an index ([Int]) or a reference to a column
+     * ([String], [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath], [KProperty], or [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor]; any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+     *
+     * This is a DSL-shorthand for [columnGroup][org.jetbrains.kotlinx.dataframe.api.columnGroup] and can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index). In addition, extra runtime checks are in place to ensure that the column
+     * you specify is actually a column group.
+     * The function can also be called on [ColumnGroups][org.jetbrains.kotlinx.dataframe.ColumnGroupReference] to create
+     * an accessor for a column group inside a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`<`[String][String]`>("colGroupA") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`(SomeType::colGroupB) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`(1) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`("columnGroupName") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`<`[String][String]`>("columnGroupName") }`
+     *
+     * To create a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for another kind of column, take a look at the functions
+     * [col][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.col],
+     * [valueCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.valueCol],
+     * and [frameCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.frameCol].
+     *
+     * @return A [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for the column group with the given argument if possible, else a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn].
+     * @throws [IllegalStateException] if the column with the given argument does not exist.
+     * @throws [IllegalArgumentException] if the column with the given argument is not a column group.
+     *
+     * @see [columnGroup]
+     * @see [ColumnsSelectionDsl.frameCol]
+     * @see [ColumnsSelectionDsl.valueCol]
+     * @see [ColumnsSelectionDsl.col]
+     *
+     *
+     *
+     * @param [name] The name of the value column.
+     */
+    private interface ColGroupNameDocs
+
+    /**
+     * ## Col Group
+     *
+     * Creates a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] (or [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]) for a column group with the given argument which can be either
+     * an index ([Int]) or a reference to a column
+     * ([String], [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath], [KProperty], or [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor]; any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+     *
+     * This is a DSL-shorthand for [columnGroup][org.jetbrains.kotlinx.dataframe.api.columnGroup] and can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index). In addition, extra runtime checks are in place to ensure that the column
+     * you specify is actually a column group.
+     * The function can also be called on [ColumnGroups][org.jetbrains.kotlinx.dataframe.ColumnGroupReference] to create
+     * an accessor for a column group inside a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`<`[String][String]`>("colGroupA") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`(SomeType::colGroupB) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`(1) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`("columnGroupName") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`<`[String][String]`>("columnGroupName") }`
+     *
+     * To create a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for another kind of column, take a look at the functions
+     * [col][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.col],
+     * [valueCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.valueCol],
+     * and [frameCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.frameCol].
+     *
+     * @return A [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for the column group with the given argument if possible, else a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn].
+     * @throws [IllegalStateException] if the column with the given argument does not exist.
+     * @throws [IllegalArgumentException] if the column with the given argument is not a column group.
+     *
+     * @see [columnGroup]
+     * @see [ColumnsSelectionDsl.frameCol]
+     * @see [ColumnsSelectionDsl.valueCol]
+     * @see [ColumnsSelectionDsl.col]
+     *
+     *
+     *
+     * @param [name] The name of the value column.
+     */
+    @Suppress("INAPPLICABLE_JVM_NAME")
+    @JvmName("colGroupUnTyped")
+    public fun colGroup(name: String): ColumnAccessor<DataRow<*>> = columnGroup<Any?>(name).ensureIsColumnGroup()
+
+    /**
+     * ## Col Group
+     *
+     * Creates a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] (or [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]) for a column group with the given argument which can be either
+     * an index ([Int]) or a reference to a column
+     * ([String], [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath], [KProperty], or [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor]; any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+     *
+     * This is a DSL-shorthand for [columnGroup][org.jetbrains.kotlinx.dataframe.api.columnGroup] and can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index). In addition, extra runtime checks are in place to ensure that the column
+     * you specify is actually a column group.
+     * The function can also be called on [ColumnGroups][org.jetbrains.kotlinx.dataframe.ColumnGroupReference] to create
+     * an accessor for a column group inside a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`<`[String][String]`>("colGroupA") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`(SomeType::colGroupB) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`(1) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`("columnGroupName") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`<`[String][String]`>("columnGroupName") }`
+     *
+     * To create a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for another kind of column, take a look at the functions
+     * [col][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.col],
+     * [valueCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.valueCol],
+     * and [frameCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.frameCol].
+     *
+     * @return A [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for the column group with the given argument if possible, else a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn].
+     * @throws [IllegalStateException] if the column with the given argument does not exist.
+     * @throws [IllegalArgumentException] if the column with the given argument is not a column group.
+     *
+     * @see [columnGroup]
+     * @see [ColumnsSelectionDsl.frameCol]
+     * @see [ColumnsSelectionDsl.valueCol]
+     * @see [ColumnsSelectionDsl.col]
+     *
+     *
+     *
+     * @param [name] The name of the value column.
+     * @param [C] The type of the column group.
+     */
+    public fun <C> colGroup(name: String): ColumnAccessor<DataRow<C>> = columnGroup<C>(name).ensureIsColumnGroup()
+
+    /**
+     * ## Col Group
+     *
+     * Creates a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] (or [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]) for a column group with the given argument which can be either
+     * an index ([Int]) or a reference to a column
+     * ([String], [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath], [KProperty], or [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor]; any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+     *
+     * This is a DSL-shorthand for [columnGroup][org.jetbrains.kotlinx.dataframe.api.columnGroup] and can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index). In addition, extra runtime checks are in place to ensure that the column
+     * you specify is actually a column group.
+     * The function can also be called on [ColumnGroups][org.jetbrains.kotlinx.dataframe.ColumnGroupReference] to create
+     * an accessor for a column group inside a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`<`[String][String]`>("colGroupA") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`(SomeType::colGroupB) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`(1) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`("columnGroupName") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`<`[String][String]`>("columnGroupName") }`
+     *
+     * To create a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for another kind of column, take a look at the functions
+     * [col][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.col],
+     * [valueCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.valueCol],
+     * and [frameCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.frameCol].
+     *
+     * @return A [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for the column group with the given argument if possible, else a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn].
+     * @throws [IllegalStateException] if the column with the given argument does not exist.
+     * @throws [IllegalArgumentException] if the column with the given argument is not a column group.
+     *
+     * @see [columnGroup]
+     * @see [ColumnsSelectionDsl.frameCol]
+     * @see [ColumnsSelectionDsl.valueCol]
+     * @see [ColumnsSelectionDsl.col]
+     *
+     *
+     *
+     * @param [name] The name of the value column.
+     */
+    @Suppress("INAPPLICABLE_JVM_NAME")
+    @JvmName("colGroupUnTyped")
+    public fun SingleColumn<DataRow<*>>.colGroup(name: String): SingleColumn<DataRow<*>> = colGroup<Any?>(name)
+
+    /**
+     * ## Col Group
+     *
+     * Creates a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] (or [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]) for a column group with the given argument which can be either
+     * an index ([Int]) or a reference to a column
+     * ([String], [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath], [KProperty], or [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor]; any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+     *
+     * This is a DSL-shorthand for [columnGroup][org.jetbrains.kotlinx.dataframe.api.columnGroup] and can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index). In addition, extra runtime checks are in place to ensure that the column
+     * you specify is actually a column group.
+     * The function can also be called on [ColumnGroups][org.jetbrains.kotlinx.dataframe.ColumnGroupReference] to create
+     * an accessor for a column group inside a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`<`[String][String]`>("colGroupA") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`(SomeType::colGroupB) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`(1) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`("columnGroupName") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`<`[String][String]`>("columnGroupName") }`
+     *
+     * To create a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for another kind of column, take a look at the functions
+     * [col][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.col],
+     * [valueCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.valueCol],
+     * and [frameCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.frameCol].
+     *
+     * @return A [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for the column group with the given argument if possible, else a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn].
+     * @throws [IllegalStateException] if the column with the given argument does not exist.
+     * @throws [IllegalArgumentException] if the column with the given argument is not a column group.
+     *
+     * @see [columnGroup]
+     * @see [ColumnsSelectionDsl.frameCol]
+     * @see [ColumnsSelectionDsl.valueCol]
+     * @see [ColumnsSelectionDsl.col]
+     *
+     *
+     *
+     * @param [name] The name of the value column.
+     * @param [C] The type of the column group.
+     */
+    public fun <C> SingleColumn<DataRow<*>>.colGroup(name: String): SingleColumn<DataRow<C>> =
+        this.ensureIsColumnGroup().transformSingle {
+            val child = it.getCol(name)?.cast<DataRow<C>>()
+                ?: throw IllegalStateException("Column group '$name' not found in column group '${it.path}'")
+            child.data.ensureIsColumnGroup()
+            listOf(child)
+        }.singleImpl()
+
+    /**
+     * ## Col Group
+     *
+     * Creates a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] (or [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]) for a column group with the given argument which can be either
+     * an index ([Int]) or a reference to a column
+     * ([String], [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath], [KProperty], or [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor]; any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+     *
+     * This is a DSL-shorthand for [columnGroup][org.jetbrains.kotlinx.dataframe.api.columnGroup] and can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index). In addition, extra runtime checks are in place to ensure that the column
+     * you specify is actually a column group.
+     * The function can also be called on [ColumnGroups][org.jetbrains.kotlinx.dataframe.ColumnGroupReference] to create
+     * an accessor for a column group inside a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`<`[String][String]`>("colGroupA") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`(SomeType::colGroupB) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`(1) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`("columnGroupName") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`<`[String][String]`>("columnGroupName") }`
+     *
+     * To create a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for another kind of column, take a look at the functions
+     * [col][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.col],
+     * [valueCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.valueCol],
+     * and [frameCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.frameCol].
+     *
+     * @return A [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for the column group with the given argument if possible, else a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn].
+     * @throws [IllegalStateException] if the column with the given argument does not exist.
+     * @throws [IllegalArgumentException] if the column with the given argument is not a column group.
+     *
+     * @see [columnGroup]
+     * @see [ColumnsSelectionDsl.frameCol]
+     * @see [ColumnsSelectionDsl.valueCol]
+     * @see [ColumnsSelectionDsl.col]
+     *
+     *
+     *
+     * @param [name] The name of the value column.
+     */
+    @Suppress("INAPPLICABLE_JVM_NAME")
+    @JvmName("colGroupUnTyped")
+    public fun AnyColumnGroupAccessor.colGroup(name: String): ColumnAccessor<DataRow<*>> = colGroup<Any?>(name)
+
+    /**
+     * ## Col Group
+     *
+     * Creates a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] (or [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]) for a column group with the given argument which can be either
+     * an index ([Int]) or a reference to a column
+     * ([String], [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath], [KProperty], or [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor]; any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+     *
+     * This is a DSL-shorthand for [columnGroup][org.jetbrains.kotlinx.dataframe.api.columnGroup] and can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index). In addition, extra runtime checks are in place to ensure that the column
+     * you specify is actually a column group.
+     * The function can also be called on [ColumnGroups][org.jetbrains.kotlinx.dataframe.ColumnGroupReference] to create
+     * an accessor for a column group inside a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`<`[String][String]`>("colGroupA") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`(SomeType::colGroupB) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`(1) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`("columnGroupName") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`<`[String][String]`>("columnGroupName") }`
+     *
+     * To create a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for another kind of column, take a look at the functions
+     * [col][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.col],
+     * [valueCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.valueCol],
+     * and [frameCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.frameCol].
+     *
+     * @return A [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for the column group with the given argument if possible, else a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn].
+     * @throws [IllegalStateException] if the column with the given argument does not exist.
+     * @throws [IllegalArgumentException] if the column with the given argument is not a column group.
+     *
+     * @see [columnGroup]
+     * @see [ColumnsSelectionDsl.frameCol]
+     * @see [ColumnsSelectionDsl.valueCol]
+     * @see [ColumnsSelectionDsl.col]
+     *
+     *
+     *
+     * @param [name] The name of the value column.
+     * @param [C] The type of the column group.
+     */
+    public fun <C> AnyColumnGroupAccessor.colGroup(name: String): ColumnAccessor<DataRow<C>> =
+        this.ensureIsColumnGroup().columnGroup<C>(name).ensureIsColumnGroup()
+
+    /**
+     * ## Col Group
+     *
+     * Creates a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] (or [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]) for a column group with the given argument which can be either
+     * an index ([Int]) or a reference to a column
+     * ([String], [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath], [KProperty], or [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor]; any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+     *
+     * This is a DSL-shorthand for [columnGroup][org.jetbrains.kotlinx.dataframe.api.columnGroup] and can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index). In addition, extra runtime checks are in place to ensure that the column
+     * you specify is actually a column group.
+     * The function can also be called on [ColumnGroups][org.jetbrains.kotlinx.dataframe.ColumnGroupReference] to create
+     * an accessor for a column group inside a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`<`[String][String]`>("colGroupA") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`(SomeType::colGroupB) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`(1) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "myColumnGroup".`[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`("columnGroupName") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "myColumnGroup".`[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`<`[String][String]`>("columnGroupName") }`
+     *
+     * To create a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for another kind of column, take a look at the functions
+     * [col][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.col],
+     * [valueCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.valueCol],
+     * and [frameCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.frameCol].
+     *
+     * @return A [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for the column group with the given argument if possible, else a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn].
+     * @throws [IllegalStateException] if the column with the given argument does not exist.
+     * @throws [IllegalArgumentException] if the column with the given argument is not a column group.
+     *
+     * @see [columnGroup]
+     * @see [ColumnsSelectionDsl.frameCol]
+     * @see [ColumnsSelectionDsl.valueCol]
+     * @see [ColumnsSelectionDsl.col]
+     *
+     *
+     *
+     * @param [name] The name of the value column.
+     */
+    @Suppress("INAPPLICABLE_JVM_NAME")
+    @JvmName("colGroupUnTyped")
+    public fun String.colGroup(name: String): ColumnAccessor<DataRow<*>> = colGroup<Any?>(name)
+
+    /**
+     * ## Col Group
+     *
+     * Creates a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] (or [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]) for a column group with the given argument which can be either
+     * an index ([Int]) or a reference to a column
+     * ([String], [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath], [KProperty], or [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor]; any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+     *
+     * This is a DSL-shorthand for [columnGroup][org.jetbrains.kotlinx.dataframe.api.columnGroup] and can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index). In addition, extra runtime checks are in place to ensure that the column
+     * you specify is actually a column group.
+     * The function can also be called on [ColumnGroups][org.jetbrains.kotlinx.dataframe.ColumnGroupReference] to create
+     * an accessor for a column group inside a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`<`[String][String]`>("colGroupA") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`(SomeType::colGroupB) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`(1) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "myColumnGroup".`[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`("columnGroupName") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "myColumnGroup".`[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`<`[String][String]`>("columnGroupName") }`
+     *
+     * To create a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for another kind of column, take a look at the functions
+     * [col][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.col],
+     * [valueCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.valueCol],
+     * and [frameCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.frameCol].
+     *
+     * @return A [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for the column group with the given argument if possible, else a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn].
+     * @throws [IllegalStateException] if the column with the given argument does not exist.
+     * @throws [IllegalArgumentException] if the column with the given argument is not a column group.
+     *
+     * @see [columnGroup]
+     * @see [ColumnsSelectionDsl.frameCol]
+     * @see [ColumnsSelectionDsl.valueCol]
+     * @see [ColumnsSelectionDsl.col]
+     *
+     *
+     *
+     * @param [name] The name of the value column.
+     * @param [C] The type of the column group.
+     */
+    public fun <C> String.colGroup(name: String): ColumnAccessor<DataRow<C>> =
+        columnGroup(this).ensureIsColumnGroup().columnGroup<C>(name).ensureIsColumnGroup()
+
+    /**
+     * ## Col Group
+     *
+     * Creates a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] (or [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]) for a column group with the given argument which can be either
+     * an index ([Int]) or a reference to a column
+     * ([String], [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath], [KProperty], or [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor]; any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+     *
+     * This is a DSL-shorthand for [columnGroup][org.jetbrains.kotlinx.dataframe.api.columnGroup] and can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index). In addition, extra runtime checks are in place to ensure that the column
+     * you specify is actually a column group.
+     * The function can also be called on [ColumnGroups][org.jetbrains.kotlinx.dataframe.ColumnGroupReference] to create
+     * an accessor for a column group inside a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`<`[String][String]`>("colGroupA") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`(SomeType::colGroupB) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`(1) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { Type::myColumnGroup.`[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`("columnGroupName") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { Type::myColumnGroup.`[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`<`[String][String]`>("columnGroupName") }`
+     *
+     * To create a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for another kind of column, take a look at the functions
+     * [col][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.col],
+     * [valueCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.valueCol],
+     * and [frameCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.frameCol].
+     *
+     * @return A [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for the column group with the given argument if possible, else a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn].
+     * @throws [IllegalStateException] if the column with the given argument does not exist.
+     * @throws [IllegalArgumentException] if the column with the given argument is not a column group.
+     *
+     * @see [columnGroup]
+     * @see [ColumnsSelectionDsl.frameCol]
+     * @see [ColumnsSelectionDsl.valueCol]
+     * @see [ColumnsSelectionDsl.col]
+     *
+     *
+     *
+     * @param [name] The name of the value column.
+     */
+    @Suppress("INAPPLICABLE_JVM_NAME")
+    @JvmName("colGroupUnTyped")
+    public fun KProperty<*>.colGroup(name: String): ColumnAccessor<DataRow<*>> = colGroup<Any?>(name)
+
+    /**
+     * ## Col Group
+     *
+     * Creates a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] (or [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]) for a column group with the given argument which can be either
+     * an index ([Int]) or a reference to a column
+     * ([String], [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath], [KProperty], or [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor]; any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+     *
+     * This is a DSL-shorthand for [columnGroup][org.jetbrains.kotlinx.dataframe.api.columnGroup] and can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index). In addition, extra runtime checks are in place to ensure that the column
+     * you specify is actually a column group.
+     * The function can also be called on [ColumnGroups][org.jetbrains.kotlinx.dataframe.ColumnGroupReference] to create
+     * an accessor for a column group inside a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`<`[String][String]`>("colGroupA") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`(SomeType::colGroupB) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`(1) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { Type::myColumnGroup.`[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`("columnGroupName") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { Type::myColumnGroup.`[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`<`[String][String]`>("columnGroupName") }`
+     *
+     * To create a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for another kind of column, take a look at the functions
+     * [col][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.col],
+     * [valueCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.valueCol],
+     * and [frameCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.frameCol].
+     *
+     * @return A [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for the column group with the given argument if possible, else a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn].
+     * @throws [IllegalStateException] if the column with the given argument does not exist.
+     * @throws [IllegalArgumentException] if the column with the given argument is not a column group.
+     *
+     * @see [columnGroup]
+     * @see [ColumnsSelectionDsl.frameCol]
+     * @see [ColumnsSelectionDsl.valueCol]
+     * @see [ColumnsSelectionDsl.col]
+     *
+     *
+     *
+     * @param [name] The name of the value column.
+     * @param [C] The type of the column group.
+     */
+    public fun <C> KProperty<*>.colGroup(name: String): ColumnAccessor<DataRow<C>> =
+        columnGroup(this).ensureIsColumnGroup().columnGroup<C>(name).ensureIsColumnGroup()
+
+    /**
+     * ## Col Group
+     *
+     * Creates a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] (or [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]) for a column group with the given argument which can be either
+     * an index ([Int]) or a reference to a column
+     * ([String], [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath], [KProperty], or [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor]; any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+     *
+     * This is a DSL-shorthand for [columnGroup][org.jetbrains.kotlinx.dataframe.api.columnGroup] and can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index). In addition, extra runtime checks are in place to ensure that the column
+     * you specify is actually a column group.
+     * The function can also be called on [ColumnGroups][org.jetbrains.kotlinx.dataframe.ColumnGroupReference] to create
+     * an accessor for a column group inside a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`<`[String][String]`>("colGroupA") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`(SomeType::colGroupB) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`(1) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "pathTo"["myColumnGroup"].`[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`("columnGroupName") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "pathTo"["myColumnGroup"].`[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`<`[String][String]`>("columnGroupName") }`
+     *
+     * To create a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for another kind of column, take a look at the functions
+     * [col][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.col],
+     * [valueCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.valueCol],
+     * and [frameCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.frameCol].
+     *
+     * @return A [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for the column group with the given argument if possible, else a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn].
+     * @throws [IllegalStateException] if the column with the given argument does not exist.
+     * @throws [IllegalArgumentException] if the column with the given argument is not a column group.
+     *
+     * @see [columnGroup]
+     * @see [ColumnsSelectionDsl.frameCol]
+     * @see [ColumnsSelectionDsl.valueCol]
+     * @see [ColumnsSelectionDsl.col]
+     *
+     *
+     *
+     * @param [name] The name of the value column.
+     */
+    @Suppress("INAPPLICABLE_JVM_NAME")
+    @JvmName("colGroupUnTyped")
+    public fun ColumnPath.colGroup(name: String): ColumnAccessor<DataRow<*>> = colGroup<Any?>(name)
+
+    /**
+     * ## Col Group
+     *
+     * Creates a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] (or [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]) for a column group with the given argument which can be either
+     * an index ([Int]) or a reference to a column
+     * ([String], [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath], [KProperty], or [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor]; any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+     *
+     * This is a DSL-shorthand for [columnGroup][org.jetbrains.kotlinx.dataframe.api.columnGroup] and can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index). In addition, extra runtime checks are in place to ensure that the column
+     * you specify is actually a column group.
+     * The function can also be called on [ColumnGroups][org.jetbrains.kotlinx.dataframe.ColumnGroupReference] to create
+     * an accessor for a column group inside a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`<`[String][String]`>("colGroupA") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`(SomeType::colGroupB) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`(1) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "pathTo"["myColumnGroup"].`[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`("columnGroupName") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "pathTo"["myColumnGroup"].`[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`<`[String][String]`>("columnGroupName") }`
+     *
+     * To create a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for another kind of column, take a look at the functions
+     * [col][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.col],
+     * [valueCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.valueCol],
+     * and [frameCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.frameCol].
+     *
+     * @return A [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for the column group with the given argument if possible, else a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn].
+     * @throws [IllegalStateException] if the column with the given argument does not exist.
+     * @throws [IllegalArgumentException] if the column with the given argument is not a column group.
+     *
+     * @see [columnGroup]
+     * @see [ColumnsSelectionDsl.frameCol]
+     * @see [ColumnsSelectionDsl.valueCol]
+     * @see [ColumnsSelectionDsl.col]
+     *
+     *
+     *
+     * @param [name] The name of the value column.
+     * @param [C] The type of the column group.
+     */
+    public fun <C> ColumnPath.colGroup(name: String): ColumnAccessor<DataRow<C>> =
+        columnGroup(this).ensureIsColumnGroup().columnGroup<C>(name).ensureIsColumnGroup()
+
+    // endregion
+
+    // region path
+
+    /**
+     * ## Col Group
+     *
+     * Creates a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] (or [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]) for a column group with the given argument which can be either
+     * an index ([Int]) or a reference to a column
+     * ([String], [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath], [KProperty], or [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor]; any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+     *
+     * This is a DSL-shorthand for [columnGroup][org.jetbrains.kotlinx.dataframe.api.columnGroup] and can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index). In addition, extra runtime checks are in place to ensure that the column
+     * you specify is actually a column group.
+     * The function can also be called on [ColumnGroups][org.jetbrains.kotlinx.dataframe.ColumnGroupReference] to create
+     * an accessor for a column group inside a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`<`[String][String]`>("colGroupA") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`(SomeType::colGroupB) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`(1) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`("pathTo"["columnGroupName"] ) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`<`[String][String]`>("pathTo"["columnGroupName"] ) }`
+     *
+     * To create a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for another kind of column, take a look at the functions
+     * [col][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.col],
+     * [valueCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.valueCol],
+     * and [frameCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.frameCol].
+     *
+     * @return A [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for the column group with the given argument if possible, else a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn].
+     * @throws [IllegalStateException] if the column with the given argument does not exist.
+     * @throws [IllegalArgumentException] if the column with the given argument is not a column group.
+     *
+     * @see [columnGroup]
+     * @see [ColumnsSelectionDsl.frameCol]
+     * @see [ColumnsSelectionDsl.valueCol]
+     * @see [ColumnsSelectionDsl.col]
+     *
+     *
+     *
+     * @param [path] The path to the value column.
+     */
+    private interface ColGroupPathDocs
+
+    /**
+     * ## Col Group
+     *
+     * Creates a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] (or [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]) for a column group with the given argument which can be either
+     * an index ([Int]) or a reference to a column
+     * ([String], [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath], [KProperty], or [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor]; any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+     *
+     * This is a DSL-shorthand for [columnGroup][org.jetbrains.kotlinx.dataframe.api.columnGroup] and can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index). In addition, extra runtime checks are in place to ensure that the column
+     * you specify is actually a column group.
+     * The function can also be called on [ColumnGroups][org.jetbrains.kotlinx.dataframe.ColumnGroupReference] to create
+     * an accessor for a column group inside a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`<`[String][String]`>("colGroupA") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`(SomeType::colGroupB) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`(1) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`("pathTo"["columnGroupName"] ) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`<`[String][String]`>("pathTo"["columnGroupName"] ) }`
+     *
+     * To create a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for another kind of column, take a look at the functions
+     * [col][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.col],
+     * [valueCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.valueCol],
+     * and [frameCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.frameCol].
+     *
+     * @return A [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for the column group with the given argument if possible, else a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn].
+     * @throws [IllegalStateException] if the column with the given argument does not exist.
+     * @throws [IllegalArgumentException] if the column with the given argument is not a column group.
+     *
+     * @see [columnGroup]
+     * @see [ColumnsSelectionDsl.frameCol]
+     * @see [ColumnsSelectionDsl.valueCol]
+     * @see [ColumnsSelectionDsl.col]
+     *
+     *
+     *
+     * @param [path] The path to the value column.
+     */
+    @Suppress("INAPPLICABLE_JVM_NAME")
+    @JvmName("colGroupUnTyped")
+    public fun colGroup(path: ColumnPath): ColumnAccessor<DataRow<*>> = columnGroup<Any?>(path).ensureIsColumnGroup()
+
+    /**
+     * ## Col Group
+     *
+     * Creates a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] (or [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]) for a column group with the given argument which can be either
+     * an index ([Int]) or a reference to a column
+     * ([String], [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath], [KProperty], or [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor]; any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+     *
+     * This is a DSL-shorthand for [columnGroup][org.jetbrains.kotlinx.dataframe.api.columnGroup] and can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index). In addition, extra runtime checks are in place to ensure that the column
+     * you specify is actually a column group.
+     * The function can also be called on [ColumnGroups][org.jetbrains.kotlinx.dataframe.ColumnGroupReference] to create
+     * an accessor for a column group inside a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`<`[String][String]`>("colGroupA") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`(SomeType::colGroupB) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`(1) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`("pathTo"["columnGroupName"] ) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`<`[String][String]`>("pathTo"["columnGroupName"] ) }`
+     *
+     * To create a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for another kind of column, take a look at the functions
+     * [col][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.col],
+     * [valueCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.valueCol],
+     * and [frameCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.frameCol].
+     *
+     * @return A [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for the column group with the given argument if possible, else a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn].
+     * @throws [IllegalStateException] if the column with the given argument does not exist.
+     * @throws [IllegalArgumentException] if the column with the given argument is not a column group.
+     *
+     * @see [columnGroup]
+     * @see [ColumnsSelectionDsl.frameCol]
+     * @see [ColumnsSelectionDsl.valueCol]
+     * @see [ColumnsSelectionDsl.col]
+     *
+     *
+     *
+     * @param [path] The path to the value column.
+     * @param [C] The type of the column group.
+     */
+    public fun <C> colGroup(path: ColumnPath): ColumnAccessor<DataRow<C>> = columnGroup<C>(path).ensureIsColumnGroup()
+
+    /**
+     * ## Col Group
+     *
+     * Creates a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] (or [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]) for a column group with the given argument which can be either
+     * an index ([Int]) or a reference to a column
+     * ([String], [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath], [KProperty], or [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor]; any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+     *
+     * This is a DSL-shorthand for [columnGroup][org.jetbrains.kotlinx.dataframe.api.columnGroup] and can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index). In addition, extra runtime checks are in place to ensure that the column
+     * you specify is actually a column group.
+     * The function can also be called on [ColumnGroups][org.jetbrains.kotlinx.dataframe.ColumnGroupReference] to create
+     * an accessor for a column group inside a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`<`[String][String]`>("colGroupA") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`(SomeType::colGroupB) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`(1) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`("pathTo"["columnGroupName"] ) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`<`[String][String]`>("pathTo"["columnGroupName"] ) }`
+     *
+     * To create a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for another kind of column, take a look at the functions
+     * [col][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.col],
+     * [valueCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.valueCol],
+     * and [frameCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.frameCol].
+     *
+     * @return A [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for the column group with the given argument if possible, else a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn].
+     * @throws [IllegalStateException] if the column with the given argument does not exist.
+     * @throws [IllegalArgumentException] if the column with the given argument is not a column group.
+     *
+     * @see [columnGroup]
+     * @see [ColumnsSelectionDsl.frameCol]
+     * @see [ColumnsSelectionDsl.valueCol]
+     * @see [ColumnsSelectionDsl.col]
+     *
+     *
+     *
+     * @param [path] The path to the value column.
+     */
+    @Suppress("INAPPLICABLE_JVM_NAME")
+    @JvmName("colGroupUnTyped")
+    public fun SingleColumn<DataRow<*>>.colGroup(path: ColumnPath): SingleColumn<DataRow<*>> = colGroup<Any?>(path)
+
+    /**
+     * ## Col Group
+     *
+     * Creates a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] (or [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]) for a column group with the given argument which can be either
+     * an index ([Int]) or a reference to a column
+     * ([String], [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath], [KProperty], or [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor]; any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+     *
+     * This is a DSL-shorthand for [columnGroup][org.jetbrains.kotlinx.dataframe.api.columnGroup] and can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index). In addition, extra runtime checks are in place to ensure that the column
+     * you specify is actually a column group.
+     * The function can also be called on [ColumnGroups][org.jetbrains.kotlinx.dataframe.ColumnGroupReference] to create
+     * an accessor for a column group inside a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`<`[String][String]`>("colGroupA") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`(SomeType::colGroupB) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`(1) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`("pathTo"["columnGroupName"] ) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`<`[String][String]`>("pathTo"["columnGroupName"] ) }`
+     *
+     * To create a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for another kind of column, take a look at the functions
+     * [col][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.col],
+     * [valueCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.valueCol],
+     * and [frameCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.frameCol].
+     *
+     * @return A [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for the column group with the given argument if possible, else a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn].
+     * @throws [IllegalStateException] if the column with the given argument does not exist.
+     * @throws [IllegalArgumentException] if the column with the given argument is not a column group.
+     *
+     * @see [columnGroup]
+     * @see [ColumnsSelectionDsl.frameCol]
+     * @see [ColumnsSelectionDsl.valueCol]
+     * @see [ColumnsSelectionDsl.col]
+     *
+     *
+     *
+     * @param [path] The path to the value column.
+     * @param [C] The type of the column group.
+     */
+    public fun <C> SingleColumn<DataRow<*>>.colGroup(path: ColumnPath): SingleColumn<DataRow<C>> =
+        this.ensureIsColumnGroup()
+            .transformSingle {
+                val child = it.getCol(path)?.cast<DataRow<C>>()
+                    ?: throw IllegalStateException("Column group '$path' not found in column group '${it.path}'")
+                child.data.ensureIsColumnGroup()
+                listOf(child)
+            }.singleImpl()
+
+    /**
+     * ## Col Group
+     *
+     * Creates a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] (or [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]) for a column group with the given argument which can be either
+     * an index ([Int]) or a reference to a column
+     * ([String], [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath], [KProperty], or [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor]; any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+     *
+     * This is a DSL-shorthand for [columnGroup][org.jetbrains.kotlinx.dataframe.api.columnGroup] and can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index). In addition, extra runtime checks are in place to ensure that the column
+     * you specify is actually a column group.
+     * The function can also be called on [ColumnGroups][org.jetbrains.kotlinx.dataframe.ColumnGroupReference] to create
+     * an accessor for a column group inside a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`<`[String][String]`>("colGroupA") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`(SomeType::colGroupB) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`(1) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`("pathTo"["columnGroupName"] ) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`<`[String][String]`>("pathTo"["columnGroupName"] ) }`
+     *
+     * To create a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for another kind of column, take a look at the functions
+     * [col][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.col],
+     * [valueCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.valueCol],
+     * and [frameCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.frameCol].
+     *
+     * @return A [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for the column group with the given argument if possible, else a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn].
+     * @throws [IllegalStateException] if the column with the given argument does not exist.
+     * @throws [IllegalArgumentException] if the column with the given argument is not a column group.
+     *
+     * @see [columnGroup]
+     * @see [ColumnsSelectionDsl.frameCol]
+     * @see [ColumnsSelectionDsl.valueCol]
+     * @see [ColumnsSelectionDsl.col]
+     *
+     *
+     *
+     * @param [path] The path to the value column.
+     */
+    @Suppress("INAPPLICABLE_JVM_NAME")
+    @JvmName("colGroupUnTyped")
+    public fun AnyColumnGroupAccessor.colGroup(path: ColumnPath): ColumnAccessor<DataRow<*>> = colGroup<Any?>(path)
+
+    /**
+     * ## Col Group
+     *
+     * Creates a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] (or [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]) for a column group with the given argument which can be either
+     * an index ([Int]) or a reference to a column
+     * ([String], [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath], [KProperty], or [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor]; any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+     *
+     * This is a DSL-shorthand for [columnGroup][org.jetbrains.kotlinx.dataframe.api.columnGroup] and can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index). In addition, extra runtime checks are in place to ensure that the column
+     * you specify is actually a column group.
+     * The function can also be called on [ColumnGroups][org.jetbrains.kotlinx.dataframe.ColumnGroupReference] to create
+     * an accessor for a column group inside a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`<`[String][String]`>("colGroupA") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`(SomeType::colGroupB) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`(1) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`("pathTo"["columnGroupName"] ) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`<`[String][String]`>("pathTo"["columnGroupName"] ) }`
+     *
+     * To create a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for another kind of column, take a look at the functions
+     * [col][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.col],
+     * [valueCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.valueCol],
+     * and [frameCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.frameCol].
+     *
+     * @return A [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for the column group with the given argument if possible, else a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn].
+     * @throws [IllegalStateException] if the column with the given argument does not exist.
+     * @throws [IllegalArgumentException] if the column with the given argument is not a column group.
+     *
+     * @see [columnGroup]
+     * @see [ColumnsSelectionDsl.frameCol]
+     * @see [ColumnsSelectionDsl.valueCol]
+     * @see [ColumnsSelectionDsl.col]
+     *
+     *
+     *
+     * @param [path] The path to the value column.
+     * @param [C] The type of the column group.
+     */
+    public fun <C> AnyColumnGroupAccessor.colGroup(path: ColumnPath): ColumnAccessor<DataRow<C>> =
+        this.ensureIsColumnGroup().columnGroup<C>(path).ensureIsColumnGroup()
+
+    /**
+     * ## Col Group
+     *
+     * Creates a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] (or [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]) for a column group with the given argument which can be either
+     * an index ([Int]) or a reference to a column
+     * ([String], [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath], [KProperty], or [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor]; any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+     *
+     * This is a DSL-shorthand for [columnGroup][org.jetbrains.kotlinx.dataframe.api.columnGroup] and can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index). In addition, extra runtime checks are in place to ensure that the column
+     * you specify is actually a column group.
+     * The function can also be called on [ColumnGroups][org.jetbrains.kotlinx.dataframe.ColumnGroupReference] to create
+     * an accessor for a column group inside a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`<`[String][String]`>("colGroupA") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`(SomeType::colGroupB) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`(1) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "myColumnGroup".`[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`("pathTo"["columnGroupName"] ) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "myColumnGroup".`[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`<`[String][String]`>("pathTo"["columnGroupName"] ) }`
+     *
+     * To create a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for another kind of column, take a look at the functions
+     * [col][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.col],
+     * [valueCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.valueCol],
+     * and [frameCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.frameCol].
+     *
+     * @return A [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for the column group with the given argument if possible, else a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn].
+     * @throws [IllegalStateException] if the column with the given argument does not exist.
+     * @throws [IllegalArgumentException] if the column with the given argument is not a column group.
+     *
+     * @see [columnGroup]
+     * @see [ColumnsSelectionDsl.frameCol]
+     * @see [ColumnsSelectionDsl.valueCol]
+     * @see [ColumnsSelectionDsl.col]
+     *
+     *
+     *
+     * @param [path] The path to the value column.
+     */
+    @Suppress("INAPPLICABLE_JVM_NAME")
+    @JvmName("colGroupUnTyped")
+    public fun String.colGroup(path: ColumnPath): ColumnAccessor<DataRow<*>> = colGroup<Any?>(path)
+
+    /**
+     * ## Col Group
+     *
+     * Creates a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] (or [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]) for a column group with the given argument which can be either
+     * an index ([Int]) or a reference to a column
+     * ([String], [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath], [KProperty], or [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor]; any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+     *
+     * This is a DSL-shorthand for [columnGroup][org.jetbrains.kotlinx.dataframe.api.columnGroup] and can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index). In addition, extra runtime checks are in place to ensure that the column
+     * you specify is actually a column group.
+     * The function can also be called on [ColumnGroups][org.jetbrains.kotlinx.dataframe.ColumnGroupReference] to create
+     * an accessor for a column group inside a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`<`[String][String]`>("colGroupA") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`(SomeType::colGroupB) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`(1) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "myColumnGroup".`[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`("pathTo"["columnGroupName"] ) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "myColumnGroup".`[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`<`[String][String]`>("pathTo"["columnGroupName"] ) }`
+     *
+     * To create a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for another kind of column, take a look at the functions
+     * [col][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.col],
+     * [valueCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.valueCol],
+     * and [frameCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.frameCol].
+     *
+     * @return A [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for the column group with the given argument if possible, else a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn].
+     * @throws [IllegalStateException] if the column with the given argument does not exist.
+     * @throws [IllegalArgumentException] if the column with the given argument is not a column group.
+     *
+     * @see [columnGroup]
+     * @see [ColumnsSelectionDsl.frameCol]
+     * @see [ColumnsSelectionDsl.valueCol]
+     * @see [ColumnsSelectionDsl.col]
+     *
+     *
+     *
+     * @param [path] The path to the value column.
+     * @param [C] The type of the column group.
+     */
+    public fun <C> String.colGroup(path: ColumnPath): ColumnAccessor<DataRow<C>> =
+        columnGroup(this).ensureIsColumnGroup().columnGroup<C>(path).ensureIsColumnGroup()
+
+    /**
+     * ## Col Group
+     *
+     * Creates a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] (or [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]) for a column group with the given argument which can be either
+     * an index ([Int]) or a reference to a column
+     * ([String], [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath], [KProperty], or [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor]; any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+     *
+     * This is a DSL-shorthand for [columnGroup][org.jetbrains.kotlinx.dataframe.api.columnGroup] and can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index). In addition, extra runtime checks are in place to ensure that the column
+     * you specify is actually a column group.
+     * The function can also be called on [ColumnGroups][org.jetbrains.kotlinx.dataframe.ColumnGroupReference] to create
+     * an accessor for a column group inside a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`<`[String][String]`>("colGroupA") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`(SomeType::colGroupB) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`(1) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { Type::myColumnGroup.`[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`("pathTo"["columnGroupName"] ) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { Type::myColumnGroup.`[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`<`[String][String]`>("pathTo"["columnGroupName"] ) }`
+     *
+     * To create a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for another kind of column, take a look at the functions
+     * [col][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.col],
+     * [valueCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.valueCol],
+     * and [frameCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.frameCol].
+     *
+     * @return A [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for the column group with the given argument if possible, else a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn].
+     * @throws [IllegalStateException] if the column with the given argument does not exist.
+     * @throws [IllegalArgumentException] if the column with the given argument is not a column group.
+     *
+     * @see [columnGroup]
+     * @see [ColumnsSelectionDsl.frameCol]
+     * @see [ColumnsSelectionDsl.valueCol]
+     * @see [ColumnsSelectionDsl.col]
+     *
+     *
+     *
+     * @param [path] The path to the value column.
+     */
+    @Suppress("INAPPLICABLE_JVM_NAME")
+    @JvmName("colGroupUnTyped")
+    public fun KProperty<*>.colGroup(path: ColumnPath): ColumnAccessor<DataRow<*>> = colGroup<Any?>(path)
+
+    /**
+     * ## Col Group
+     *
+     * Creates a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] (or [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]) for a column group with the given argument which can be either
+     * an index ([Int]) or a reference to a column
+     * ([String], [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath], [KProperty], or [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor]; any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+     *
+     * This is a DSL-shorthand for [columnGroup][org.jetbrains.kotlinx.dataframe.api.columnGroup] and can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index). In addition, extra runtime checks are in place to ensure that the column
+     * you specify is actually a column group.
+     * The function can also be called on [ColumnGroups][org.jetbrains.kotlinx.dataframe.ColumnGroupReference] to create
+     * an accessor for a column group inside a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`<`[String][String]`>("colGroupA") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`(SomeType::colGroupB) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`(1) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { Type::myColumnGroup.`[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`("pathTo"["columnGroupName"] ) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { Type::myColumnGroup.`[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`<`[String][String]`>("pathTo"["columnGroupName"] ) }`
+     *
+     * To create a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for another kind of column, take a look at the functions
+     * [col][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.col],
+     * [valueCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.valueCol],
+     * and [frameCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.frameCol].
+     *
+     * @return A [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for the column group with the given argument if possible, else a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn].
+     * @throws [IllegalStateException] if the column with the given argument does not exist.
+     * @throws [IllegalArgumentException] if the column with the given argument is not a column group.
+     *
+     * @see [columnGroup]
+     * @see [ColumnsSelectionDsl.frameCol]
+     * @see [ColumnsSelectionDsl.valueCol]
+     * @see [ColumnsSelectionDsl.col]
+     *
+     *
+     *
+     * @param [path] The path to the value column.
+     * @param [C] The type of the column group.
+     */
+    public fun <C> KProperty<*>.colGroup(path: ColumnPath): ColumnAccessor<DataRow<C>> =
+        columnGroup(this).ensureIsColumnGroup().columnGroup<C>(path).ensureIsColumnGroup()
+
+    /**
+     * ## Col Group
+     *
+     * Creates a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] (or [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]) for a column group with the given argument which can be either
+     * an index ([Int]) or a reference to a column
+     * ([String], [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath], [KProperty], or [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor]; any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+     *
+     * This is a DSL-shorthand for [columnGroup][org.jetbrains.kotlinx.dataframe.api.columnGroup] and can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index). In addition, extra runtime checks are in place to ensure that the column
+     * you specify is actually a column group.
+     * The function can also be called on [ColumnGroups][org.jetbrains.kotlinx.dataframe.ColumnGroupReference] to create
+     * an accessor for a column group inside a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`<`[String][String]`>("colGroupA") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`(SomeType::colGroupB) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`(1) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "pathTo"["myColumnGroup"].`[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`("pathTo"["columnGroupName"] ) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "pathTo"["myColumnGroup"].`[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`<`[String][String]`>("pathTo"["columnGroupName"] ) }`
+     *
+     * To create a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for another kind of column, take a look at the functions
+     * [col][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.col],
+     * [valueCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.valueCol],
+     * and [frameCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.frameCol].
+     *
+     * @return A [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for the column group with the given argument if possible, else a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn].
+     * @throws [IllegalStateException] if the column with the given argument does not exist.
+     * @throws [IllegalArgumentException] if the column with the given argument is not a column group.
+     *
+     * @see [columnGroup]
+     * @see [ColumnsSelectionDsl.frameCol]
+     * @see [ColumnsSelectionDsl.valueCol]
+     * @see [ColumnsSelectionDsl.col]
+     *
+     *
+     *
+     * @param [path] The path to the value column.
+     */
+    @Suppress("INAPPLICABLE_JVM_NAME")
+    @JvmName("colGroupUnTyped")
+    public fun ColumnPath.colGroup(path: ColumnPath): ColumnAccessor<DataRow<*>> = colGroup<Any?>(path)
+
+    /**
+     * ## Col Group
+     *
+     * Creates a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] (or [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]) for a column group with the given argument which can be either
+     * an index ([Int]) or a reference to a column
+     * ([String], [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath], [KProperty], or [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor]; any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+     *
+     * This is a DSL-shorthand for [columnGroup][org.jetbrains.kotlinx.dataframe.api.columnGroup] and can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index). In addition, extra runtime checks are in place to ensure that the column
+     * you specify is actually a column group.
+     * The function can also be called on [ColumnGroups][org.jetbrains.kotlinx.dataframe.ColumnGroupReference] to create
+     * an accessor for a column group inside a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`<`[String][String]`>("colGroupA") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`(SomeType::colGroupB) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`(1) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "pathTo"["myColumnGroup"].`[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`("pathTo"["columnGroupName"] ) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "pathTo"["myColumnGroup"].`[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`<`[String][String]`>("pathTo"["columnGroupName"] ) }`
+     *
+     * To create a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for another kind of column, take a look at the functions
+     * [col][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.col],
+     * [valueCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.valueCol],
+     * and [frameCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.frameCol].
+     *
+     * @return A [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for the column group with the given argument if possible, else a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn].
+     * @throws [IllegalStateException] if the column with the given argument does not exist.
+     * @throws [IllegalArgumentException] if the column with the given argument is not a column group.
+     *
+     * @see [columnGroup]
+     * @see [ColumnsSelectionDsl.frameCol]
+     * @see [ColumnsSelectionDsl.valueCol]
+     * @see [ColumnsSelectionDsl.col]
+     *
+     *
+     *
+     * @param [path] The path to the value column.
+     * @param [C] The type of the column group.
+     */
+    public fun <C> ColumnPath.colGroup(path: ColumnPath): ColumnAccessor<DataRow<C>> =
+        columnGroup(this).ensureIsColumnGroup().columnGroup<C>(path).ensureIsColumnGroup()
+
+    // endregion
+
+    // region property
+
+    /**
+     * ## Col Group
+     *
+     * Creates a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] (or [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]) for a column group with the given argument which can be either
+     * an index ([Int]) or a reference to a column
+     * ([String], [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath], [KProperty], or [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor]; any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+     *
+     * This is a DSL-shorthand for [columnGroup][org.jetbrains.kotlinx.dataframe.api.columnGroup] and can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index). In addition, extra runtime checks are in place to ensure that the column
+     * you specify is actually a column group.
+     * The function can also be called on [ColumnGroups][org.jetbrains.kotlinx.dataframe.ColumnGroupReference] to create
+     * an accessor for a column group inside a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`<`[String][String]`>("colGroupA") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`(SomeType::colGroupB) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`(1) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`(Type::columnGroupA) }`
+     *
+     * To create a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for another kind of column, take a look at the functions
+     * [col][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.col],
+     * [valueCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.valueCol],
+     * and [frameCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.frameCol].
+     *
+     * @return A [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for the column group with the given argument if possible, else a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn].
+     * @throws [IllegalStateException] if the column with the given argument does not exist.
+     * @throws [IllegalArgumentException] if the column with the given argument is not a column group.
+     *
+     * @see [columnGroup]
+     * @see [ColumnsSelectionDsl.frameCol]
+     * @see [ColumnsSelectionDsl.valueCol]
+     * @see [ColumnsSelectionDsl.col]
+     *
+     *
+     *
+     * @param [property] The [KProperty] reference to the value column.
+     * @param [C] The type of the column group.
+     */
+    private interface ColGroupKPropertyDocs
+
+    /**
+     * ## Col Group
+     *
+     * Creates a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] (or [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]) for a column group with the given argument which can be either
+     * an index ([Int]) or a reference to a column
+     * ([String], [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath], [KProperty], or [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor]; any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+     *
+     * This is a DSL-shorthand for [columnGroup][org.jetbrains.kotlinx.dataframe.api.columnGroup] and can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index). In addition, extra runtime checks are in place to ensure that the column
+     * you specify is actually a column group.
+     * The function can also be called on [ColumnGroups][org.jetbrains.kotlinx.dataframe.ColumnGroupReference] to create
+     * an accessor for a column group inside a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`<`[String][String]`>("colGroupA") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`(SomeType::colGroupB) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`(1) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`(Type::columnGroupA) }`
+     *
+     * To create a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for another kind of column, take a look at the functions
+     * [col][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.col],
+     * [valueCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.valueCol],
+     * and [frameCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.frameCol].
+     *
+     * @return A [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for the column group with the given argument if possible, else a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn].
+     * @throws [IllegalStateException] if the column with the given argument does not exist.
+     * @throws [IllegalArgumentException] if the column with the given argument is not a column group.
+     *
+     * @see [columnGroup]
+     * @see [ColumnsSelectionDsl.frameCol]
+     * @see [ColumnsSelectionDsl.valueCol]
+     * @see [ColumnsSelectionDsl.col]
+     *
+     *
+     *
+     * @param [property] The [KProperty] reference to the value column.
+     * @param [C] The type of the column group.
+     */
+    @Suppress("INAPPLICABLE_JVM_NAME")
+    @JvmName("colGroupDataRowKProperty")
+    public fun <C> colGroup(property: KProperty<DataRow<C>>): SingleColumn<DataRow<C>> =
+        columnGroup(property).ensureIsColumnGroup()
+
+    /**
+     * ## Col Group
+     *
+     * Creates a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] (or [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]) for a column group with the given argument which can be either
+     * an index ([Int]) or a reference to a column
+     * ([String], [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath], [KProperty], or [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor]; any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+     *
+     * This is a DSL-shorthand for [columnGroup][org.jetbrains.kotlinx.dataframe.api.columnGroup] and can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index). In addition, extra runtime checks are in place to ensure that the column
+     * you specify is actually a column group.
+     * The function can also be called on [ColumnGroups][org.jetbrains.kotlinx.dataframe.ColumnGroupReference] to create
+     * an accessor for a column group inside a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`<`[String][String]`>("colGroupA") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`(SomeType::colGroupB) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`(1) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`(Type::columnGroupA) }`
+     *
+     * To create a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for another kind of column, take a look at the functions
+     * [col][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.col],
+     * [valueCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.valueCol],
+     * and [frameCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.frameCol].
+     *
+     * @return A [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for the column group with the given argument if possible, else a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn].
+     * @throws [IllegalStateException] if the column with the given argument does not exist.
+     * @throws [IllegalArgumentException] if the column with the given argument is not a column group.
+     *
+     * @see [columnGroup]
+     * @see [ColumnsSelectionDsl.frameCol]
+     * @see [ColumnsSelectionDsl.valueCol]
+     * @see [ColumnsSelectionDsl.col]
+     *
+     *
+     *
+     * @param [property] The [KProperty] reference to the value column.
+     * @param [C] The type of the column group.
+     */
+    public fun <C> colGroup(property: KProperty<C>): SingleColumn<DataRow<C>> =
+        columnGroup(property).ensureIsColumnGroup()
+
+    /**
+     * ## Col Group
+     *
+     * Creates a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] (or [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]) for a column group with the given argument which can be either
+     * an index ([Int]) or a reference to a column
+     * ([String], [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath], [KProperty], or [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor]; any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+     *
+     * This is a DSL-shorthand for [columnGroup][org.jetbrains.kotlinx.dataframe.api.columnGroup] and can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index). In addition, extra runtime checks are in place to ensure that the column
+     * you specify is actually a column group.
+     * The function can also be called on [ColumnGroups][org.jetbrains.kotlinx.dataframe.ColumnGroupReference] to create
+     * an accessor for a column group inside a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`<`[String][String]`>("colGroupA") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`(SomeType::colGroupB) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`(1) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`(Type::columnGroupA) }`
+     *
+     * To create a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for another kind of column, take a look at the functions
+     * [col][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.col],
+     * [valueCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.valueCol],
+     * and [frameCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.frameCol].
+     *
+     * @return A [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for the column group with the given argument if possible, else a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn].
+     * @throws [IllegalStateException] if the column with the given argument does not exist.
+     * @throws [IllegalArgumentException] if the column with the given argument is not a column group.
+     *
+     * @see [columnGroup]
+     * @see [ColumnsSelectionDsl.frameCol]
+     * @see [ColumnsSelectionDsl.valueCol]
+     * @see [ColumnsSelectionDsl.col]
+     *
+     *
+     *
+     * @param [property] The [KProperty] reference to the value column.
+     * @param [C] The type of the column group.
+     */
+    @Suppress("INAPPLICABLE_JVM_NAME")
+    @JvmName("colGroupDataRowKProperty")
+    public fun <C> SingleColumn<DataRow<*>>.colGroup(property: KProperty<DataRow<C>>): SingleColumn<DataRow<C>> =
+        colGroup<C>(property.name)
+
+    /**
+     * ## Col Group
+     *
+     * Creates a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] (or [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]) for a column group with the given argument which can be either
+     * an index ([Int]) or a reference to a column
+     * ([String], [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath], [KProperty], or [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor]; any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+     *
+     * This is a DSL-shorthand for [columnGroup][org.jetbrains.kotlinx.dataframe.api.columnGroup] and can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index). In addition, extra runtime checks are in place to ensure that the column
+     * you specify is actually a column group.
+     * The function can also be called on [ColumnGroups][org.jetbrains.kotlinx.dataframe.ColumnGroupReference] to create
+     * an accessor for a column group inside a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`<`[String][String]`>("colGroupA") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`(SomeType::colGroupB) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`(1) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`(Type::columnGroupA) }`
+     *
+     * To create a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for another kind of column, take a look at the functions
+     * [col][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.col],
+     * [valueCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.valueCol],
+     * and [frameCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.frameCol].
+     *
+     * @return A [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for the column group with the given argument if possible, else a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn].
+     * @throws [IllegalStateException] if the column with the given argument does not exist.
+     * @throws [IllegalArgumentException] if the column with the given argument is not a column group.
+     *
+     * @see [columnGroup]
+     * @see [ColumnsSelectionDsl.frameCol]
+     * @see [ColumnsSelectionDsl.valueCol]
+     * @see [ColumnsSelectionDsl.col]
+     *
+     *
+     *
+     * @param [property] The [KProperty] reference to the value column.
+     * @param [C] The type of the column group.
+     */
+    public fun <C> SingleColumn<DataRow<*>>.colGroup(property: KProperty<C>): SingleColumn<DataRow<C>> =
+        colGroup<C>(property.name)
+
+    /**
+     * ## Col Group
+     *
+     * Creates a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] (or [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]) for a column group with the given argument which can be either
+     * an index ([Int]) or a reference to a column
+     * ([String], [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath], [KProperty], or [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor]; any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+     *
+     * This is a DSL-shorthand for [columnGroup][org.jetbrains.kotlinx.dataframe.api.columnGroup] and can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index). In addition, extra runtime checks are in place to ensure that the column
+     * you specify is actually a column group.
+     * The function can also be called on [ColumnGroups][org.jetbrains.kotlinx.dataframe.ColumnGroupReference] to create
+     * an accessor for a column group inside a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`<`[String][String]`>("colGroupA") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`(SomeType::colGroupB) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`(1) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`(Type::columnGroupA) }`
+     *
+     * To create a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for another kind of column, take a look at the functions
+     * [col][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.col],
+     * [valueCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.valueCol],
+     * and [frameCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.frameCol].
+     *
+     * @return A [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for the column group with the given argument if possible, else a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn].
+     * @throws [IllegalStateException] if the column with the given argument does not exist.
+     * @throws [IllegalArgumentException] if the column with the given argument is not a column group.
+     *
+     * @see [columnGroup]
+     * @see [ColumnsSelectionDsl.frameCol]
+     * @see [ColumnsSelectionDsl.valueCol]
+     * @see [ColumnsSelectionDsl.col]
+     *
+     *
+     *
+     * @param [property] The [KProperty] reference to the value column.
+     * @param [C] The type of the column group.
+     */
+    @Suppress("INAPPLICABLE_JVM_NAME")
+    @JvmName("colGroupDataRowKProperty")
+    public fun <C> AnyColumnGroupAccessor.colGroup(property: KProperty<DataRow<C>>): ColumnAccessor<DataRow<C>> =
+        this.ensureIsColumnGroup().columnGroup(property).ensureIsColumnGroup()
+
+    /**
+     * ## Col Group
+     *
+     * Creates a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] (or [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]) for a column group with the given argument which can be either
+     * an index ([Int]) or a reference to a column
+     * ([String], [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath], [KProperty], or [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor]; any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+     *
+     * This is a DSL-shorthand for [columnGroup][org.jetbrains.kotlinx.dataframe.api.columnGroup] and can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index). In addition, extra runtime checks are in place to ensure that the column
+     * you specify is actually a column group.
+     * The function can also be called on [ColumnGroups][org.jetbrains.kotlinx.dataframe.ColumnGroupReference] to create
+     * an accessor for a column group inside a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`<`[String][String]`>("colGroupA") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`(SomeType::colGroupB) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`(1) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`(Type::columnGroupA) }`
+     *
+     * To create a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for another kind of column, take a look at the functions
+     * [col][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.col],
+     * [valueCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.valueCol],
+     * and [frameCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.frameCol].
+     *
+     * @return A [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for the column group with the given argument if possible, else a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn].
+     * @throws [IllegalStateException] if the column with the given argument does not exist.
+     * @throws [IllegalArgumentException] if the column with the given argument is not a column group.
+     *
+     * @see [columnGroup]
+     * @see [ColumnsSelectionDsl.frameCol]
+     * @see [ColumnsSelectionDsl.valueCol]
+     * @see [ColumnsSelectionDsl.col]
+     *
+     *
+     *
+     * @param [property] The [KProperty] reference to the value column.
+     * @param [C] The type of the column group.
+     */
+    public fun <C> AnyColumnGroupAccessor.colGroup(property: KProperty<C>): ColumnAccessor<DataRow<C>> =
+        this.ensureIsColumnGroup().columnGroup(property).ensureIsColumnGroup()
+
+    /**
+     * ## Col Group
+     *
+     * Creates a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] (or [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]) for a column group with the given argument which can be either
+     * an index ([Int]) or a reference to a column
+     * ([String], [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath], [KProperty], or [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor]; any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+     *
+     * This is a DSL-shorthand for [columnGroup][org.jetbrains.kotlinx.dataframe.api.columnGroup] and can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index). In addition, extra runtime checks are in place to ensure that the column
+     * you specify is actually a column group.
+     * The function can also be called on [ColumnGroups][org.jetbrains.kotlinx.dataframe.ColumnGroupReference] to create
+     * an accessor for a column group inside a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`<`[String][String]`>("colGroupA") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`(SomeType::colGroupB) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`(1) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "myColumnGroup".`[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`(Type::columnGroupA) }`
+     *
+     * To create a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for another kind of column, take a look at the functions
+     * [col][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.col],
+     * [valueCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.valueCol],
+     * and [frameCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.frameCol].
+     *
+     * @return A [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for the column group with the given argument if possible, else a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn].
+     * @throws [IllegalStateException] if the column with the given argument does not exist.
+     * @throws [IllegalArgumentException] if the column with the given argument is not a column group.
+     *
+     * @see [columnGroup]
+     * @see [ColumnsSelectionDsl.frameCol]
+     * @see [ColumnsSelectionDsl.valueCol]
+     * @see [ColumnsSelectionDsl.col]
+     *
+     *
+     *
+     * @param [property] The [KProperty] reference to the value column.
+     * @param [C] The type of the column group.
+     */
+    @Suppress("INAPPLICABLE_JVM_NAME")
+    @JvmName("colGroupDataRowKProperty")
+    public fun <C> String.colGroup(property: KProperty<DataRow<C>>): ColumnAccessor<DataRow<C>> =
+        columnGroup(this).ensureIsColumnGroup().columnGroup(property).ensureIsColumnGroup()
+
+    /**
+     * ## Col Group
+     *
+     * Creates a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] (or [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]) for a column group with the given argument which can be either
+     * an index ([Int]) or a reference to a column
+     * ([String], [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath], [KProperty], or [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor]; any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+     *
+     * This is a DSL-shorthand for [columnGroup][org.jetbrains.kotlinx.dataframe.api.columnGroup] and can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index). In addition, extra runtime checks are in place to ensure that the column
+     * you specify is actually a column group.
+     * The function can also be called on [ColumnGroups][org.jetbrains.kotlinx.dataframe.ColumnGroupReference] to create
+     * an accessor for a column group inside a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`<`[String][String]`>("colGroupA") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`(SomeType::colGroupB) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`(1) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "myColumnGroup".`[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`(Type::columnGroupA) }`
+     *
+     * To create a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for another kind of column, take a look at the functions
+     * [col][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.col],
+     * [valueCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.valueCol],
+     * and [frameCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.frameCol].
+     *
+     * @return A [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for the column group with the given argument if possible, else a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn].
+     * @throws [IllegalStateException] if the column with the given argument does not exist.
+     * @throws [IllegalArgumentException] if the column with the given argument is not a column group.
+     *
+     * @see [columnGroup]
+     * @see [ColumnsSelectionDsl.frameCol]
+     * @see [ColumnsSelectionDsl.valueCol]
+     * @see [ColumnsSelectionDsl.col]
+     *
+     *
+     *
+     * @param [property] The [KProperty] reference to the value column.
+     * @param [C] The type of the column group.
+     */
+    public fun <C> String.colGroup(property: KProperty<C>): ColumnAccessor<DataRow<C>> =
+        columnGroup(this).ensureIsColumnGroup().columnGroup(property).ensureIsColumnGroup()
+
+    /**
+     * ## Col Group
+     *
+     * Creates a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] (or [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]) for a column group with the given argument which can be either
+     * an index ([Int]) or a reference to a column
+     * ([String], [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath], [KProperty], or [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor]; any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+     *
+     * This is a DSL-shorthand for [columnGroup][org.jetbrains.kotlinx.dataframe.api.columnGroup] and can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index). In addition, extra runtime checks are in place to ensure that the column
+     * you specify is actually a column group.
+     * The function can also be called on [ColumnGroups][org.jetbrains.kotlinx.dataframe.ColumnGroupReference] to create
+     * an accessor for a column group inside a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`<`[String][String]`>("colGroupA") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`(SomeType::colGroupB) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`(1) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { Type::myColumnGroup.`[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`(Type::columnGroupA) }`
+     *
+     * To create a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for another kind of column, take a look at the functions
+     * [col][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.col],
+     * [valueCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.valueCol],
+     * and [frameCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.frameCol].
+     *
+     * @return A [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for the column group with the given argument if possible, else a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn].
+     * @throws [IllegalStateException] if the column with the given argument does not exist.
+     * @throws [IllegalArgumentException] if the column with the given argument is not a column group.
+     *
+     * @see [columnGroup]
+     * @see [ColumnsSelectionDsl.frameCol]
+     * @see [ColumnsSelectionDsl.valueCol]
+     * @see [ColumnsSelectionDsl.col]
+     *
+     *
+     *
+     * @param [property] The [KProperty] reference to the value column.
+     * @param [C] The type of the column group.
+     */
+    @Suppress("INAPPLICABLE_JVM_NAME")
+    @JvmName("colGroupDataRowKProperty")
+    public fun <C> KProperty<*>.colGroup(property: KProperty<DataRow<C>>): ColumnAccessor<DataRow<C>> =
+        columnGroup(this).ensureIsColumnGroup().columnGroup(property).ensureIsColumnGroup()
+
+    /**
+     * ## Col Group
+     *
+     * Creates a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] (or [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]) for a column group with the given argument which can be either
+     * an index ([Int]) or a reference to a column
+     * ([String], [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath], [KProperty], or [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor]; any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+     *
+     * This is a DSL-shorthand for [columnGroup][org.jetbrains.kotlinx.dataframe.api.columnGroup] and can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index). In addition, extra runtime checks are in place to ensure that the column
+     * you specify is actually a column group.
+     * The function can also be called on [ColumnGroups][org.jetbrains.kotlinx.dataframe.ColumnGroupReference] to create
+     * an accessor for a column group inside a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`<`[String][String]`>("colGroupA") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`(SomeType::colGroupB) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`(1) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { Type::myColumnGroup.`[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`(Type::columnGroupA) }`
+     *
+     * To create a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for another kind of column, take a look at the functions
+     * [col][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.col],
+     * [valueCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.valueCol],
+     * and [frameCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.frameCol].
+     *
+     * @return A [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for the column group with the given argument if possible, else a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn].
+     * @throws [IllegalStateException] if the column with the given argument does not exist.
+     * @throws [IllegalArgumentException] if the column with the given argument is not a column group.
+     *
+     * @see [columnGroup]
+     * @see [ColumnsSelectionDsl.frameCol]
+     * @see [ColumnsSelectionDsl.valueCol]
+     * @see [ColumnsSelectionDsl.col]
+     *
+     *
+     *
+     * @param [property] The [KProperty] reference to the value column.
+     * @param [C] The type of the column group.
+     */
+    public fun <C> KProperty<*>.colGroup(property: KProperty<C>): ColumnAccessor<DataRow<C>> =
+        columnGroup(this).ensureIsColumnGroup().columnGroup(property).ensureIsColumnGroup()
+
+    /**
+     * ## Col Group
+     *
+     * Creates a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] (or [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]) for a column group with the given argument which can be either
+     * an index ([Int]) or a reference to a column
+     * ([String], [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath], [KProperty], or [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor]; any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+     *
+     * This is a DSL-shorthand for [columnGroup][org.jetbrains.kotlinx.dataframe.api.columnGroup] and can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index). In addition, extra runtime checks are in place to ensure that the column
+     * you specify is actually a column group.
+     * The function can also be called on [ColumnGroups][org.jetbrains.kotlinx.dataframe.ColumnGroupReference] to create
+     * an accessor for a column group inside a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`<`[String][String]`>("colGroupA") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`(SomeType::colGroupB) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`(1) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "pathTo"["myColumnGroup"].`[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`(Type::columnGroupA) }`
+     *
+     * To create a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for another kind of column, take a look at the functions
+     * [col][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.col],
+     * [valueCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.valueCol],
+     * and [frameCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.frameCol].
+     *
+     * @return A [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for the column group with the given argument if possible, else a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn].
+     * @throws [IllegalStateException] if the column with the given argument does not exist.
+     * @throws [IllegalArgumentException] if the column with the given argument is not a column group.
+     *
+     * @see [columnGroup]
+     * @see [ColumnsSelectionDsl.frameCol]
+     * @see [ColumnsSelectionDsl.valueCol]
+     * @see [ColumnsSelectionDsl.col]
+     *
+     *
+     *
+     * @param [property] The [KProperty] reference to the value column.
+     * @param [C] The type of the column group.
+     */
+    @Suppress("INAPPLICABLE_JVM_NAME")
+    @JvmName("colGroupDataRowKProperty")
+    public fun <C> ColumnPath.colGroup(property: KProperty<DataRow<C>>): ColumnAccessor<DataRow<C>> =
+        columnGroup(this).ensureIsColumnGroup().columnGroup(property).ensureIsColumnGroup()
+
+    /**
+     * ## Col Group
+     *
+     * Creates a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] (or [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]) for a column group with the given argument which can be either
+     * an index ([Int]) or a reference to a column
+     * ([String], [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath], [KProperty], or [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor]; any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+     *
+     * This is a DSL-shorthand for [columnGroup][org.jetbrains.kotlinx.dataframe.api.columnGroup] and can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index). In addition, extra runtime checks are in place to ensure that the column
+     * you specify is actually a column group.
+     * The function can also be called on [ColumnGroups][org.jetbrains.kotlinx.dataframe.ColumnGroupReference] to create
+     * an accessor for a column group inside a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`<`[String][String]`>("colGroupA") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`(SomeType::colGroupB) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`(1) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "pathTo"["myColumnGroup"].`[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`(Type::columnGroupA) }`
+     *
+     * To create a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for another kind of column, take a look at the functions
+     * [col][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.col],
+     * [valueCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.valueCol],
+     * and [frameCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.frameCol].
+     *
+     * @return A [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for the column group with the given argument if possible, else a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn].
+     * @throws [IllegalStateException] if the column with the given argument does not exist.
+     * @throws [IllegalArgumentException] if the column with the given argument is not a column group.
+     *
+     * @see [columnGroup]
+     * @see [ColumnsSelectionDsl.frameCol]
+     * @see [ColumnsSelectionDsl.valueCol]
+     * @see [ColumnsSelectionDsl.col]
+     *
+     *
+     *
+     * @param [property] The [KProperty] reference to the value column.
+     * @param [C] The type of the column group.
+     */
+    public fun <C> ColumnPath.colGroup(property: KProperty<C>): ColumnAccessor<DataRow<C>> =
+        columnGroup(this).ensureIsColumnGroup().columnGroup(property).ensureIsColumnGroup()
+
+    // endregion
+
+    // region index
+
+    /**
+     * ## Col Group
+     *
+     * Creates a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] (or [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]) for a column group with the given argument which can be either
+     * an index ([Int]) or a reference to a column
+     * ([String], [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath], [KProperty], or [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor]; any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+     *
+     * This is a DSL-shorthand for [columnGroup][org.jetbrains.kotlinx.dataframe.api.columnGroup] and can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index). In addition, extra runtime checks are in place to ensure that the column
+     * you specify is actually a column group.
+     * The function can also be called on [ColumnGroups][org.jetbrains.kotlinx.dataframe.ColumnGroupReference] to create
+     * an accessor for a column group inside a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`<`[String][String]`>("colGroupA") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`(SomeType::colGroupB) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`(1) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`(0) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`<`[String][String]`>(0) }`
+     *
+     * To create a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for another kind of column, take a look at the functions
+     * [col][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.col],
+     * [valueCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.valueCol],
+     * and [frameCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.frameCol].
+     *
+     * @return A [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for the column group with the given argument if possible, else a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn].
+     * @throws [IllegalStateException] if the column with the given argument does not exist.
+     * @throws [IllegalArgumentException] if the column with the given argument is not a column group.
+     *
+     * @see [columnGroup]
+     * @see [ColumnsSelectionDsl.frameCol]
+     * @see [ColumnsSelectionDsl.valueCol]
+     * @see [ColumnsSelectionDsl.col]
+     *
+     *
+     *
+     * @param [index] The index of the value column.
+     * @throws [IndexOutOfBoundsException] if the index is out of bounds.
+     */
+    private interface ColGroupIndexDocs
+
+    /**
+     * ## Col Group
+     *
+     * Creates a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] (or [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]) for a column group with the given argument which can be either
+     * an index ([Int]) or a reference to a column
+     * ([String], [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath], [KProperty], or [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor]; any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+     *
+     * This is a DSL-shorthand for [columnGroup][org.jetbrains.kotlinx.dataframe.api.columnGroup] and can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index). In addition, extra runtime checks are in place to ensure that the column
+     * you specify is actually a column group.
+     * The function can also be called on [ColumnGroups][org.jetbrains.kotlinx.dataframe.ColumnGroupReference] to create
+     * an accessor for a column group inside a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`<`[String][String]`>("colGroupA") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`(SomeType::colGroupB) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`(1) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { `[colsOf][ColumnsSelectionDsl.colsOf]`<`[Int][Int]`>().`[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`(0) }`
+     *
+     * To create a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for another kind of column, take a look at the functions
+     * [col][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.col],
+     * [valueCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.valueCol],
+     * and [frameCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.frameCol].
+     *
+     * @return A [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for the column group with the given argument if possible, else a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn].
+     * @throws [IllegalStateException] if the column with the given argument does not exist.
+     * @throws [IllegalArgumentException] if the column with the given argument is not a column group.
+     *
+     * @see [columnGroup]
+     * @see [ColumnsSelectionDsl.frameCol]
+     * @see [ColumnsSelectionDsl.valueCol]
+     * @see [ColumnsSelectionDsl.col]
+     *
+     *
+     *
+     * @param [index] The index of the value column.
+     * @throws [IndexOutOfBoundsException] if the index is out of bounds.
+     * @param [C] The type of the column group.
+     *
+     */
+    @Suppress("INAPPLICABLE_JVM_NAME")
+    @JvmName("ColumnSetDataRowColGroupIndex")
+    public fun <C> ColumnSet<DataRow<C>>.colGroup(index: Int): SingleColumn<DataRow<C>> =
+        getAt(index).ensureIsColumnGroup()
+
+    /**
+     * ## Col Group
+     *
+     * Creates a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] (or [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]) for a column group with the given argument which can be either
+     * an index ([Int]) or a reference to a column
+     * ([String], [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath], [KProperty], or [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor]; any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+     *
+     * This is a DSL-shorthand for [columnGroup][org.jetbrains.kotlinx.dataframe.api.columnGroup] and can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index). In addition, extra runtime checks are in place to ensure that the column
+     * you specify is actually a column group.
+     * The function can also be called on [ColumnGroups][org.jetbrains.kotlinx.dataframe.ColumnGroupReference] to create
+     * an accessor for a column group inside a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`<`[String][String]`>("colGroupA") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`(SomeType::colGroupB) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`(1) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { `[colsOf][ColumnsSelectionDsl.colsOf]`<`[Int][Int]`>().`[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`(0) }`
+     *
+     * To create a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for another kind of column, take a look at the functions
+     * [col][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.col],
+     * [valueCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.valueCol],
+     * and [frameCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.frameCol].
+     *
+     * @return A [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for the column group with the given argument if possible, else a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn].
+     * @throws [IllegalStateException] if the column with the given argument does not exist.
+     * @throws [IllegalArgumentException] if the column with the given argument is not a column group.
+     *
+     * @see [columnGroup]
+     * @see [ColumnsSelectionDsl.frameCol]
+     * @see [ColumnsSelectionDsl.valueCol]
+     * @see [ColumnsSelectionDsl.col]
+     *
+     *
+     *
+     * @param [index] The index of the value column.
+     * @throws [IndexOutOfBoundsException] if the index is out of bounds.
+     * @param [C] The type of the column group.
+     *
+     */
+    public fun ColumnSet<*>.colGroup(index: Int): SingleColumn<DataRow<*>> =
+        getAt(index).cast<DataRow<*>>().ensureIsColumnGroup()
+
+    /**
+     * ## Col Group
+     *
+     * Creates a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] (or [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]) for a column group with the given argument which can be either
+     * an index ([Int]) or a reference to a column
+     * ([String], [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath], [KProperty], or [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor]; any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+     *
+     * This is a DSL-shorthand for [columnGroup][org.jetbrains.kotlinx.dataframe.api.columnGroup] and can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index). In addition, extra runtime checks are in place to ensure that the column
+     * you specify is actually a column group.
+     * The function can also be called on [ColumnGroups][org.jetbrains.kotlinx.dataframe.ColumnGroupReference] to create
+     * an accessor for a column group inside a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`<`[String][String]`>("colGroupA") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`(SomeType::colGroupB) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`(1) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`(0) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`<`[String][String]`>(0) }`
+     *
+     * To create a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for another kind of column, take a look at the functions
+     * [col][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.col],
+     * [valueCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.valueCol],
+     * and [frameCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.frameCol].
+     *
+     * @return A [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for the column group with the given argument if possible, else a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn].
+     * @throws [IllegalStateException] if the column with the given argument does not exist.
+     * @throws [IllegalArgumentException] if the column with the given argument is not a column group.
+     *
+     * @see [columnGroup]
+     * @see [ColumnsSelectionDsl.frameCol]
+     * @see [ColumnsSelectionDsl.valueCol]
+     * @see [ColumnsSelectionDsl.col]
+     *
+     *
+     *
+     * @param [index] The index of the value column.
+     * @throws [IndexOutOfBoundsException] if the index is out of bounds.
+     */
+    @Suppress("INAPPLICABLE_JVM_NAME")
+    @JvmName("colGroupUnTyped")
+    public fun ColumnsSelectionDsl<*>.colGroup(index: Int): SingleColumn<DataRow<*>> = colGroup<Any?>(index)
+
+    /**
+     * ## Col Group
+     *
+     * Creates a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] (or [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]) for a column group with the given argument which can be either
+     * an index ([Int]) or a reference to a column
+     * ([String], [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath], [KProperty], or [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor]; any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+     *
+     * This is a DSL-shorthand for [columnGroup][org.jetbrains.kotlinx.dataframe.api.columnGroup] and can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index). In addition, extra runtime checks are in place to ensure that the column
+     * you specify is actually a column group.
+     * The function can also be called on [ColumnGroups][org.jetbrains.kotlinx.dataframe.ColumnGroupReference] to create
+     * an accessor for a column group inside a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`<`[String][String]`>("colGroupA") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`(SomeType::colGroupB) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`(1) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`(0) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`<`[String][String]`>(0) }`
+     *
+     * To create a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for another kind of column, take a look at the functions
+     * [col][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.col],
+     * [valueCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.valueCol],
+     * and [frameCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.frameCol].
+     *
+     * @return A [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for the column group with the given argument if possible, else a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn].
+     * @throws [IllegalStateException] if the column with the given argument does not exist.
+     * @throws [IllegalArgumentException] if the column with the given argument is not a column group.
+     *
+     * @see [columnGroup]
+     * @see [ColumnsSelectionDsl.frameCol]
+     * @see [ColumnsSelectionDsl.valueCol]
+     * @see [ColumnsSelectionDsl.col]
+     *
+     *
+     *
+     * @param [index] The index of the value column.
+     * @throws [IndexOutOfBoundsException] if the index is out of bounds.
+     * @param [C] The type of the column group.
+     */
+    public fun <C> ColumnsSelectionDsl<*>.colGroup(index: Int): SingleColumn<DataRow<C>> =
+        asSingleColumn().colGroup<C>(index)
+
+    /**
+     * ## Col Group
+     *
+     * Creates a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] (or [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]) for a column group with the given argument which can be either
+     * an index ([Int]) or a reference to a column
+     * ([String], [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath], [KProperty], or [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor]; any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+     *
+     * This is a DSL-shorthand for [columnGroup][org.jetbrains.kotlinx.dataframe.api.columnGroup] and can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index). In addition, extra runtime checks are in place to ensure that the column
+     * you specify is actually a column group.
+     * The function can also be called on [ColumnGroups][org.jetbrains.kotlinx.dataframe.ColumnGroupReference] to create
+     * an accessor for a column group inside a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`<`[String][String]`>("colGroupA") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`(SomeType::colGroupB) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`(1) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`(0) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`<`[String][String]`>(0) }`
+     *
+     * To create a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for another kind of column, take a look at the functions
+     * [col][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.col],
+     * [valueCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.valueCol],
+     * and [frameCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.frameCol].
+     *
+     * @return A [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for the column group with the given argument if possible, else a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn].
+     * @throws [IllegalStateException] if the column with the given argument does not exist.
+     * @throws [IllegalArgumentException] if the column with the given argument is not a column group.
+     *
+     * @see [columnGroup]
+     * @see [ColumnsSelectionDsl.frameCol]
+     * @see [ColumnsSelectionDsl.valueCol]
+     * @see [ColumnsSelectionDsl.col]
+     *
+     *
+     *
+     * @param [index] The index of the value column.
+     * @throws [IndexOutOfBoundsException] if the index is out of bounds.
+     */
+    @Suppress("INAPPLICABLE_JVM_NAME")
+    @JvmName("colGroupUnTyped")
+    public fun SingleColumn<DataRow<*>>.colGroup(index: Int): SingleColumn<DataRow<*>> = colGroup<Any?>(index)
+
+    /**
+     * ## Col Group
+     *
+     * Creates a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] (or [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]) for a column group with the given argument which can be either
+     * an index ([Int]) or a reference to a column
+     * ([String], [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath], [KProperty], or [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor]; any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+     *
+     * This is a DSL-shorthand for [columnGroup][org.jetbrains.kotlinx.dataframe.api.columnGroup] and can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index). In addition, extra runtime checks are in place to ensure that the column
+     * you specify is actually a column group.
+     * The function can also be called on [ColumnGroups][org.jetbrains.kotlinx.dataframe.ColumnGroupReference] to create
+     * an accessor for a column group inside a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`<`[String][String]`>("colGroupA") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`(SomeType::colGroupB) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`(1) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`(0) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`<`[String][String]`>(0) }`
+     *
+     * To create a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for another kind of column, take a look at the functions
+     * [col][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.col],
+     * [valueCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.valueCol],
+     * and [frameCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.frameCol].
+     *
+     * @return A [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for the column group with the given argument if possible, else a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn].
+     * @throws [IllegalStateException] if the column with the given argument does not exist.
+     * @throws [IllegalArgumentException] if the column with the given argument is not a column group.
+     *
+     * @see [columnGroup]
+     * @see [ColumnsSelectionDsl.frameCol]
+     * @see [ColumnsSelectionDsl.valueCol]
+     * @see [ColumnsSelectionDsl.col]
+     *
+     *
+     *
+     * @param [index] The index of the value column.
+     * @throws [IndexOutOfBoundsException] if the index is out of bounds.
+     * @param [C] The type of the column group.
+     */
+    public fun <C> SingleColumn<DataRow<*>>.colGroup(index: Int): SingleColumn<DataRow<C>> =
+        this.ensureIsColumnGroup()
+            .allColumnsInternal()
+            .getAt(index)
+            .cast<DataRow<C>>()
+            .ensureIsColumnGroup()
+
+    /**
+     * ## Col Group
+     *
+     * Creates a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] (or [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]) for a column group with the given argument which can be either
+     * an index ([Int]) or a reference to a column
+     * ([String], [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath], [KProperty], or [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor]; any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+     *
+     * This is a DSL-shorthand for [columnGroup][org.jetbrains.kotlinx.dataframe.api.columnGroup] and can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index). In addition, extra runtime checks are in place to ensure that the column
+     * you specify is actually a column group.
+     * The function can also be called on [ColumnGroups][org.jetbrains.kotlinx.dataframe.ColumnGroupReference] to create
+     * an accessor for a column group inside a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`<`[String][String]`>("colGroupA") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`(SomeType::colGroupB) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`(1) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "myColumnGroup".`[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`(0) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "myColumnGroup".`[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`<`[String][String]`>(0) }`
+     *
+     * To create a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for another kind of column, take a look at the functions
+     * [col][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.col],
+     * [valueCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.valueCol],
+     * and [frameCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.frameCol].
+     *
+     * @return A [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for the column group with the given argument if possible, else a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn].
+     * @throws [IllegalStateException] if the column with the given argument does not exist.
+     * @throws [IllegalArgumentException] if the column with the given argument is not a column group.
+     *
+     * @see [columnGroup]
+     * @see [ColumnsSelectionDsl.frameCol]
+     * @see [ColumnsSelectionDsl.valueCol]
+     * @see [ColumnsSelectionDsl.col]
+     *
+     *
+     *
+     * @param [index] The index of the value column.
+     * @throws [IndexOutOfBoundsException] if the index is out of bounds.
+     */
+    @Suppress("INAPPLICABLE_JVM_NAME")
+    @JvmName("colGroupUnTyped")
+    public fun String.colGroup(index: Int): SingleColumn<DataRow<*>> = colGroup<Any?>(index)
+
+    /**
+     * ## Col Group
+     *
+     * Creates a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] (or [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]) for a column group with the given argument which can be either
+     * an index ([Int]) or a reference to a column
+     * ([String], [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath], [KProperty], or [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor]; any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+     *
+     * This is a DSL-shorthand for [columnGroup][org.jetbrains.kotlinx.dataframe.api.columnGroup] and can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index). In addition, extra runtime checks are in place to ensure that the column
+     * you specify is actually a column group.
+     * The function can also be called on [ColumnGroups][org.jetbrains.kotlinx.dataframe.ColumnGroupReference] to create
+     * an accessor for a column group inside a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`<`[String][String]`>("colGroupA") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`(SomeType::colGroupB) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`(1) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "myColumnGroup".`[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`(0) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "myColumnGroup".`[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`<`[String][String]`>(0) }`
+     *
+     * To create a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for another kind of column, take a look at the functions
+     * [col][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.col],
+     * [valueCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.valueCol],
+     * and [frameCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.frameCol].
+     *
+     * @return A [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for the column group with the given argument if possible, else a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn].
+     * @throws [IllegalStateException] if the column with the given argument does not exist.
+     * @throws [IllegalArgumentException] if the column with the given argument is not a column group.
+     *
+     * @see [columnGroup]
+     * @see [ColumnsSelectionDsl.frameCol]
+     * @see [ColumnsSelectionDsl.valueCol]
+     * @see [ColumnsSelectionDsl.col]
+     *
+     *
+     *
+     * @param [index] The index of the value column.
+     * @throws [IndexOutOfBoundsException] if the index is out of bounds.
+     * @param [C] The type of the column group.
+     */
+    public fun <C> String.colGroup(index: Int): SingleColumn<DataRow<C>> = columnGroup(this).colGroup<C>(index)
+
+    /**
+     * ## Col Group
+     *
+     * Creates a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] (or [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]) for a column group with the given argument which can be either
+     * an index ([Int]) or a reference to a column
+     * ([String], [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath], [KProperty], or [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor]; any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+     *
+     * This is a DSL-shorthand for [columnGroup][org.jetbrains.kotlinx.dataframe.api.columnGroup] and can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index). In addition, extra runtime checks are in place to ensure that the column
+     * you specify is actually a column group.
+     * The function can also be called on [ColumnGroups][org.jetbrains.kotlinx.dataframe.ColumnGroupReference] to create
+     * an accessor for a column group inside a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`<`[String][String]`>("colGroupA") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`(SomeType::colGroupB) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`(1) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { Type::myColumnGroup.`[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`(0) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { Type::myColumnGroup.`[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`<`[String][String]`>(0) }`
+     *
+     * To create a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for another kind of column, take a look at the functions
+     * [col][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.col],
+     * [valueCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.valueCol],
+     * and [frameCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.frameCol].
+     *
+     * @return A [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for the column group with the given argument if possible, else a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn].
+     * @throws [IllegalStateException] if the column with the given argument does not exist.
+     * @throws [IllegalArgumentException] if the column with the given argument is not a column group.
+     *
+     * @see [columnGroup]
+     * @see [ColumnsSelectionDsl.frameCol]
+     * @see [ColumnsSelectionDsl.valueCol]
+     * @see [ColumnsSelectionDsl.col]
+     *
+     *
+     *
+     * @param [index] The index of the value column.
+     * @throws [IndexOutOfBoundsException] if the index is out of bounds.
+     */
+    @Suppress("INAPPLICABLE_JVM_NAME")
+    @JvmName("colGroupUnTyped")
+    public fun KProperty<*>.colGroup(index: Int): SingleColumn<DataRow<*>> = colGroup<Any?>(index)
+
+    /**
+     * ## Col Group
+     *
+     * Creates a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] (or [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]) for a column group with the given argument which can be either
+     * an index ([Int]) or a reference to a column
+     * ([String], [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath], [KProperty], or [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor]; any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+     *
+     * This is a DSL-shorthand for [columnGroup][org.jetbrains.kotlinx.dataframe.api.columnGroup] and can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index). In addition, extra runtime checks are in place to ensure that the column
+     * you specify is actually a column group.
+     * The function can also be called on [ColumnGroups][org.jetbrains.kotlinx.dataframe.ColumnGroupReference] to create
+     * an accessor for a column group inside a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`<`[String][String]`>("colGroupA") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`(SomeType::colGroupB) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`(1) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { Type::myColumnGroup.`[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`(0) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { Type::myColumnGroup.`[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`<`[String][String]`>(0) }`
+     *
+     * To create a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for another kind of column, take a look at the functions
+     * [col][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.col],
+     * [valueCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.valueCol],
+     * and [frameCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.frameCol].
+     *
+     * @return A [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for the column group with the given argument if possible, else a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn].
+     * @throws [IllegalStateException] if the column with the given argument does not exist.
+     * @throws [IllegalArgumentException] if the column with the given argument is not a column group.
+     *
+     * @see [columnGroup]
+     * @see [ColumnsSelectionDsl.frameCol]
+     * @see [ColumnsSelectionDsl.valueCol]
+     * @see [ColumnsSelectionDsl.col]
+     *
+     *
+     *
+     * @param [index] The index of the value column.
+     * @throws [IndexOutOfBoundsException] if the index is out of bounds.
+     * @param [C] The type of the column group.
+     */
+    public fun <C> KProperty<*>.colGroup(index: Int): SingleColumn<DataRow<C>> = columnGroup(this).colGroup<C>(index)
+
+    /**
+     * ## Col Group
+     *
+     * Creates a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] (or [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]) for a column group with the given argument which can be either
+     * an index ([Int]) or a reference to a column
+     * ([String], [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath], [KProperty], or [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor]; any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+     *
+     * This is a DSL-shorthand for [columnGroup][org.jetbrains.kotlinx.dataframe.api.columnGroup] and can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index). In addition, extra runtime checks are in place to ensure that the column
+     * you specify is actually a column group.
+     * The function can also be called on [ColumnGroups][org.jetbrains.kotlinx.dataframe.ColumnGroupReference] to create
+     * an accessor for a column group inside a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`<`[String][String]`>("colGroupA") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`(SomeType::colGroupB) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`(1) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "pathTo"["myColumnGroup"].`[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`(0) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "pathTo"["myColumnGroup"].`[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`<`[String][String]`>(0) }`
+     *
+     * To create a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for another kind of column, take a look at the functions
+     * [col][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.col],
+     * [valueCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.valueCol],
+     * and [frameCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.frameCol].
+     *
+     * @return A [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for the column group with the given argument if possible, else a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn].
+     * @throws [IllegalStateException] if the column with the given argument does not exist.
+     * @throws [IllegalArgumentException] if the column with the given argument is not a column group.
+     *
+     * @see [columnGroup]
+     * @see [ColumnsSelectionDsl.frameCol]
+     * @see [ColumnsSelectionDsl.valueCol]
+     * @see [ColumnsSelectionDsl.col]
+     *
+     *
+     *
+     * @param [index] The index of the value column.
+     * @throws [IndexOutOfBoundsException] if the index is out of bounds.
+     */
+    @Suppress("INAPPLICABLE_JVM_NAME")
+    @JvmName("colGroupUnTyped")
+    public fun ColumnPath.colGroup(index: Int): SingleColumn<DataRow<*>> = colGroup<Any?>(index)
+
+    /**
+     * ## Col Group
+     *
+     * Creates a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] (or [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]) for a column group with the given argument which can be either
+     * an index ([Int]) or a reference to a column
+     * ([String], [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath], [KProperty], or [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor]; any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+     *
+     * This is a DSL-shorthand for [columnGroup][org.jetbrains.kotlinx.dataframe.api.columnGroup] and can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index). In addition, extra runtime checks are in place to ensure that the column
+     * you specify is actually a column group.
+     * The function can also be called on [ColumnGroups][org.jetbrains.kotlinx.dataframe.ColumnGroupReference] to create
+     * an accessor for a column group inside a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`<`[String][String]`>("colGroupA") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`(SomeType::colGroupB) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`(1) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "pathTo"["myColumnGroup"].`[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`(0) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "pathTo"["myColumnGroup"].`[colGroup][org.jetbrains.kotlinx.dataframe.api.ColGroupColumnsSelectionDsl.colGroup]`<`[String][String]`>(0) }`
+     *
+     * To create a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for another kind of column, take a look at the functions
+     * [col][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.col],
+     * [valueCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.valueCol],
+     * and [frameCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.frameCol].
+     *
+     * @return A [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for the column group with the given argument if possible, else a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn].
+     * @throws [IllegalStateException] if the column with the given argument does not exist.
+     * @throws [IllegalArgumentException] if the column with the given argument is not a column group.
+     *
+     * @see [columnGroup]
+     * @see [ColumnsSelectionDsl.frameCol]
+     * @see [ColumnsSelectionDsl.valueCol]
+     * @see [ColumnsSelectionDsl.col]
+     *
+     *
+     *
+     * @param [index] The index of the value column.
+     * @throws [IndexOutOfBoundsException] if the index is out of bounds.
+     * @param [C] The type of the column group.
+     */
+    public fun <C> ColumnPath.colGroup(index: Int): SingleColumn<DataRow<C>> = columnGroup(this).colGroup<C>(index)
+
+    // endregion
+}
+
+/**
+ * Checks the validity of this [SingleColumn],
+ * by adding a check to see it's a [ColumnGroup] (so, a [SingleColumn]<*>)
+ * and throwing an [IllegalArgumentException] if it's not.
+ */
+@PublishedApi
+internal fun <C> SingleColumn<DataRow<C>>.ensureIsColumnGroup(): SingleColumn<DataRow<C>> =
+    onResolve { col: ColumnWithPath<*>? ->
+        require(col?.isColumnGroup() != false) {
+            "Column at '${col?.path?.joinToString()}' is not a ColumnGroup, but a ${col?.kind()}."
+        }
+    }
+
+/** Checks the validity of this [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn],
+ * by adding a check to see it's a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup] (so, a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]<*>)
+ * and throwing an [IllegalArgumentException] if it's not. */
+internal fun <C> ColumnAccessor<DataRow<C>>.ensureIsColumnGroup(): ColumnAccessor<DataRow<C>> =
+    onResolve { col: ColumnWithPath<*>? ->
+        require(col?.isColumnGroup() != false) {
+            "Column at '${col?.path?.joinToString()}' is not a ColumnGroup, but a ${col?.kind()}."
+        }
+    }
+
+// endregion
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/colGroups.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/colGroups.kt
new file mode 100644
index 000000000..192d2b212
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/colGroups.kt
@@ -0,0 +1,363 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import org.jetbrains.kotlinx.dataframe.AnyRow
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.DataRow
+import org.jetbrains.kotlinx.dataframe.Predicate
+import org.jetbrains.kotlinx.dataframe.api.ColGroupsColumnsSelectionDsl.Grammar
+import org.jetbrains.kotlinx.dataframe.columns.ColumnGroup
+import org.jetbrains.kotlinx.dataframe.columns.ColumnPath
+import org.jetbrains.kotlinx.dataframe.columns.ColumnReference
+import org.jetbrains.kotlinx.dataframe.columns.ColumnSet
+import org.jetbrains.kotlinx.dataframe.columns.ColumnsResolver
+import org.jetbrains.kotlinx.dataframe.columns.SingleColumn
+import org.jetbrains.kotlinx.dataframe.documentation.AccessApi
+import org.jetbrains.kotlinx.dataframe.impl.columns.TransformableColumnSet
+import kotlin.reflect.KProperty
+
+// region ColumnsSelectionDsl
+
+/**
+ * ## Column Groups [Columns Selection DSL][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl]
+ *
+ * See [Grammar] for all functions in this interface.
+ */
+public interface ColGroupsColumnsSelectionDsl {
+
+    /**
+     * ## Column Groups Grammar
+     *
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * [(What is this notation?)][org.jetbrains.kotlinx.dataframe.documentation.DslGrammar]
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  ### Definitions:
+     *  `columnSet: `[`ColumnSet`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]`<*>`
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  `columnGroup: `[`SingleColumn`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]`<`[`DataRow`][org.jetbrains.kotlinx.dataframe.DataRow]`<*>> | `[`String`][String]`  |  `[`KProperty`][kotlin.reflect.KProperty]`<* | `[`DataRow`][org.jetbrains.kotlinx.dataframe.DataRow]`<*>> | `[`ColumnPath`][org.jetbrains.kotlinx.dataframe.columns.ColumnPath]
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  `condition: `[`ColumnFilter`][org.jetbrains.kotlinx.dataframe.ColumnFilter]
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  ### What can be called directly in the [Columns Selection DSL][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl]:
+     *
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  [**`colGroups`**][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroups]`  [  `**`{ `**[`condition`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ConditionDef]**` }`**` ]`
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  ### What can be called on a [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]:
+     *
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  [`columnSet`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ColumnSetDef]
+     *
+     *  &nbsp;&nbsp;&nbsp;&nbsp;__`.`__[**`colGroups`**][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroups]`  [  `**`{ `**[`condition`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ConditionDef]**` }`**` ]`
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  ### What can be called on a [Column Group (reference)][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ColumnGroupDef]:
+     *
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  [`columnGroup`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ColumnGroupDef]
+     *
+     *  &nbsp;&nbsp;&nbsp;&nbsp;__`.`__[**`colGroups`**][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroups]`  [  `**`{ `**[`condition`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ConditionDef]**` }`**` ]`
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     */
+    public interface Grammar {
+
+        /** [**`colGroups`**][ColumnsSelectionDsl.colGroups] */
+        public interface PlainDslName
+
+        /** __`.`__[**`colGroups`**][ColumnsSelectionDsl.colGroups] */
+        public interface ColumnSetName
+
+        /** __`.`__[**`colGroups`**][ColumnsSelectionDsl.colGroups] */
+        public interface ColumnGroupName
+    }
+
+    /**
+     * ## Column Groups
+     * Creates a subset of columns from [this] that are [ColumnGroups][ColumnGroup].
+     *
+     * You can optionally use a [filter] to only include certain columns.
+     * [colGroups] can be called using any of the supported [APIs][AccessApi] (+ [ColumnPath]).
+     *
+     * This function operates solely on columns at the top-level.
+     *
+     * ### Check out: [Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][DataFrame.select]`  {  `[colGroups][ColumnsSelectionDsl.colGroups]` { it.`[name][ColumnReference.name]`.`[startsWith][String.startsWith]`("my") } }`
+     *
+     * `df.`[select][DataFrame.select]`  {  `[colsAtAnyDepth][ColumnsSelectionDsl.colsAtAnyDepth]`().`[colGroups][ColumnsSelectionDsl.colGroups]`() }`
+     *
+     * `df.`[select][DataFrame.select]` { "myColGroup".`[colGroups][String.colGroups]`() }`
+     *
+     * #### Examples for this overload:
+     *
+     *
+     *
+     * @param [filter] An optional [predicate][Predicate] to filter the column groups by.
+     * @return A [ColumnSet] of [ColumnGroups][ColumnGroup].
+     * @see [ColumnsSelectionDsl.colsOfKind]
+     * @see [ColumnsSelectionDsl.cols]
+     * @see [ColumnsSelectionDsl.frameCols]
+     * @see [ColumnsSelectionDsl.valueCols]
+     */
+    private interface CommonColGroupsDocs {
+
+        /** Example argument */
+        interface ExampleArg
+    }
+
+    /**
+     * ## Column Groups
+     * Creates a subset of columns from [this] that are [ColumnGroups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * You can optionally use a [filter] to only include certain columns.
+     * [colGroups][org.jetbrains.kotlinx.dataframe.api.ColGroupsColumnsSelectionDsl.colGroups] can be called using any of the supported [APIs][org.jetbrains.kotlinx.dataframe.documentation.AccessApi] (+ [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath]).
+     *
+     * This function operates solely on columns at the top-level.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColGroupsColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroups][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroups]` { it.`[name][org.jetbrains.kotlinx.dataframe.columns.ColumnReference.name]`.`[startsWith][String.startsWith]`("my") } }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsAtAnyDepth][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsAtAnyDepth]`().`[colGroups][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroups]`() }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "myColGroup".`[colGroups][kotlin.String.colGroups]`() }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][DataFrame.select]`  {  `[cols][ColumnsSelectionDsl.cols]` { it.`[name][ColumnReference.name]`.`[startsWith][String.startsWith]`("my") }.`[colGroups][ColumnSet.colGroups]`() }`
+     *
+     * `// NOTE: This can be shortened to just:`
+     *
+     * `df.`[select][DataFrame.select]`  {  `[colGroups][ColumnsSelectionDsl.colGroups]` { it.`[name][ColumnReference.name]`.`[startsWith][String.startsWith]`("my") } }`
+     *
+     * @param [filter] An optional [predicate][org.jetbrains.kotlinx.dataframe.Predicate] to filter the column groups by.
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] of [ColumnGroups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     * @see [ColumnsSelectionDsl.colsOfKind]
+     * @see [ColumnsSelectionDsl.cols]
+     * @see [ColumnsSelectionDsl.frameCols]
+     * @see [ColumnsSelectionDsl.valueCols]
+     */
+    public fun ColumnSet<*>.colGroups(filter: Predicate<ColumnGroup<*>> = { true }): TransformableColumnSet<AnyRow> =
+        columnGroupsInternal(filter)
+
+    /**
+     * ## Column Groups
+     * Creates a subset of columns from [this] that are [ColumnGroups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * You can optionally use a [filter] to only include certain columns.
+     * [colGroups][org.jetbrains.kotlinx.dataframe.api.ColGroupsColumnsSelectionDsl.colGroups] can be called using any of the supported [APIs][org.jetbrains.kotlinx.dataframe.documentation.AccessApi] (+ [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath]).
+     *
+     * This function operates solely on columns at the top-level.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColGroupsColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroups][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroups]` { it.`[name][org.jetbrains.kotlinx.dataframe.columns.ColumnReference.name]`.`[startsWith][String.startsWith]`("my") } }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsAtAnyDepth][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsAtAnyDepth]`().`[colGroups][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroups]`() }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "myColGroup".`[colGroups][kotlin.String.colGroups]`() }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][DataFrame.select]`  {  `[colGroups][ColumnsSelectionDsl.colGroups]`() }`
+     *
+     * `df.`[select][DataFrame.select]`  {  `[colGroups][ColumnsSelectionDsl.colGroups]` { it.`[name][ColumnReference.name]`.`[startsWith][String.startsWith]`("my") } }`
+     *
+     * @param [filter] An optional [predicate][org.jetbrains.kotlinx.dataframe.Predicate] to filter the column groups by.
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] of [ColumnGroups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     * @see [ColumnsSelectionDsl.colsOfKind]
+     * @see [ColumnsSelectionDsl.cols]
+     * @see [ColumnsSelectionDsl.frameCols]
+     * @see [ColumnsSelectionDsl.valueCols]
+     */
+    public fun ColumnsSelectionDsl<*>.colGroups(
+        filter: Predicate<ColumnGroup<*>> = { true },
+    ): TransformableColumnSet<AnyRow> = asSingleColumn().columnGroupsInternal(filter)
+
+    /**
+     * ## Column Groups
+     * Creates a subset of columns from [this] that are [ColumnGroups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * You can optionally use a [filter] to only include certain columns.
+     * [colGroups][org.jetbrains.kotlinx.dataframe.api.ColGroupsColumnsSelectionDsl.colGroups] can be called using any of the supported [APIs][org.jetbrains.kotlinx.dataframe.documentation.AccessApi] (+ [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath]).
+     *
+     * This function operates solely on columns at the top-level.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColGroupsColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroups][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroups]` { it.`[name][org.jetbrains.kotlinx.dataframe.columns.ColumnReference.name]`.`[startsWith][String.startsWith]`("my") } }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsAtAnyDepth][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsAtAnyDepth]`().`[colGroups][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroups]`() }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "myColGroup".`[colGroups][kotlin.String.colGroups]`() }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][DataFrame.select]` { myColGroup.`[colGroups][SingleColumn.colGroups]`() }`
+     *
+     * `df.`[select][DataFrame.select]` { myColGroup.`[colGroups][SingleColumn.colGroups]` { it.`[name][ColumnReference.name]`.`[startsWith][String.startsWith]`("my") } }`
+     *
+     * @param [filter] An optional [predicate][org.jetbrains.kotlinx.dataframe.Predicate] to filter the column groups by.
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] of [ColumnGroups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     * @see [ColumnsSelectionDsl.colsOfKind]
+     * @see [ColumnsSelectionDsl.cols]
+     * @see [ColumnsSelectionDsl.frameCols]
+     * @see [ColumnsSelectionDsl.valueCols]
+     */
+    public fun SingleColumn<DataRow<*>>.colGroups(
+        filter: Predicate<ColumnGroup<*>> = { true },
+    ): TransformableColumnSet<AnyRow> = this.ensureIsColumnGroup().columnGroupsInternal(filter)
+
+    /**
+     * ## Column Groups
+     * Creates a subset of columns from [this] that are [ColumnGroups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * You can optionally use a [filter] to only include certain columns.
+     * [colGroups][org.jetbrains.kotlinx.dataframe.api.ColGroupsColumnsSelectionDsl.colGroups] can be called using any of the supported [APIs][org.jetbrains.kotlinx.dataframe.documentation.AccessApi] (+ [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath]).
+     *
+     * This function operates solely on columns at the top-level.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColGroupsColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroups][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroups]` { it.`[name][org.jetbrains.kotlinx.dataframe.columns.ColumnReference.name]`.`[startsWith][String.startsWith]`("my") } }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsAtAnyDepth][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsAtAnyDepth]`().`[colGroups][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroups]`() }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "myColGroup".`[colGroups][kotlin.String.colGroups]`() }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][DataFrame.select]` { "myColGroup".`[colGroups][String.colGroups]` { it.`[name][ColumnReference.name]`.`[startsWith][String.startsWith]`("my") } }`
+     *
+     * `df.`[select][DataFrame.select]` { "myColGroup".`[colGroups][String.colGroups]`() }`
+     *
+     * @param [filter] An optional [predicate][org.jetbrains.kotlinx.dataframe.Predicate] to filter the column groups by.
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] of [ColumnGroups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     * @see [ColumnsSelectionDsl.colsOfKind]
+     * @see [ColumnsSelectionDsl.cols]
+     * @see [ColumnsSelectionDsl.frameCols]
+     * @see [ColumnsSelectionDsl.valueCols]
+     */
+    public fun String.colGroups(filter: Predicate<ColumnGroup<*>> = { true }): TransformableColumnSet<AnyRow> =
+        columnGroup(this).colGroups(filter)
+
+    /**
+     * ## Column Groups
+     * Creates a subset of columns from [this] that are [ColumnGroups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * You can optionally use a [filter] to only include certain columns.
+     * [colGroups][org.jetbrains.kotlinx.dataframe.api.ColGroupsColumnsSelectionDsl.colGroups] can be called using any of the supported [APIs][org.jetbrains.kotlinx.dataframe.documentation.AccessApi] (+ [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath]).
+     *
+     * This function operates solely on columns at the top-level.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColGroupsColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroups][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroups]` { it.`[name][org.jetbrains.kotlinx.dataframe.columns.ColumnReference.name]`.`[startsWith][String.startsWith]`("my") } }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsAtAnyDepth][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsAtAnyDepth]`().`[colGroups][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroups]`() }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "myColGroup".`[colGroups][kotlin.String.colGroups]`() }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][DataFrame.select]`  {  `[colGroup][ColumnsSelectionDsl.colGroup]`(Type::myColGroup).`[colGroups][SingleColumn.colGroups]` { it.`[name][ColumnReference.name]`.`[startsWith][String.startsWith]`("my") } }`
+     *
+     * `df.`[select][DataFrame.select]` { DataSchemaType::myColGroup.`[colGroups][KProperty.colGroups]`() }`
+     *
+     * @param [filter] An optional [predicate][org.jetbrains.kotlinx.dataframe.Predicate] to filter the column groups by.
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] of [ColumnGroups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     * @see [ColumnsSelectionDsl.colsOfKind]
+     * @see [ColumnsSelectionDsl.cols]
+     * @see [ColumnsSelectionDsl.frameCols]
+     * @see [ColumnsSelectionDsl.valueCols]
+     */
+    public fun KProperty<*>.colGroups(filter: Predicate<ColumnGroup<*>> = { true }): TransformableColumnSet<AnyRow> =
+        columnGroup(this).colGroups(filter)
+
+    /**
+     * ## Column Groups
+     * Creates a subset of columns from [this] that are [ColumnGroups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * You can optionally use a [filter] to only include certain columns.
+     * [colGroups][org.jetbrains.kotlinx.dataframe.api.ColGroupsColumnsSelectionDsl.colGroups] can be called using any of the supported [APIs][org.jetbrains.kotlinx.dataframe.documentation.AccessApi] (+ [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath]).
+     *
+     * This function operates solely on columns at the top-level.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColGroupsColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroups][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroups]` { it.`[name][org.jetbrains.kotlinx.dataframe.columns.ColumnReference.name]`.`[startsWith][String.startsWith]`("my") } }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsAtAnyDepth][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsAtAnyDepth]`().`[colGroups][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroups]`() }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "myColGroup".`[colGroups][kotlin.String.colGroups]`() }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][DataFrame.select]` { "pathTo"["myGroupCol"].`[colGroups][ColumnPath.colGroups]`() }`
+     *
+     * @param [filter] An optional [predicate][org.jetbrains.kotlinx.dataframe.Predicate] to filter the column groups by.
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] of [ColumnGroups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     * @see [ColumnsSelectionDsl.colsOfKind]
+     * @see [ColumnsSelectionDsl.cols]
+     * @see [ColumnsSelectionDsl.frameCols]
+     * @see [ColumnsSelectionDsl.valueCols]
+     */
+    public fun ColumnPath.colGroups(filter: Predicate<ColumnGroup<*>> = { true }): TransformableColumnSet<AnyRow> =
+        columnGroup(this).colGroups(filter)
+}
+
+/**
+ * Returns a TransformableColumnSet containing the column groups that satisfy the given filter.
+ *
+ * @param filter The filter function to apply on each column group. Must accept a ColumnGroup object and return a Boolean.
+ * @return A [TransformableColumnSet] containing the column groups that satisfy the filter.
+ */
+@Suppress("UNCHECKED_CAST")
+internal fun ColumnsResolver<*>.columnGroupsInternal(
+    filter: (ColumnGroup<*>) -> Boolean,
+): TransformableColumnSet<AnyRow> = colsInternal { it.isColumnGroup() && filter(it) } as TransformableColumnSet<AnyRow>
+
+// endregion
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/cols.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/cols.kt
new file mode 100644
index 000000000..ddf58b840
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/cols.kt
@@ -0,0 +1,4933 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import org.jetbrains.kotlinx.dataframe.ColumnFilter
+import org.jetbrains.kotlinx.dataframe.DataColumn
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.DataRow
+import org.jetbrains.kotlinx.dataframe.columns.ColumnPath
+import org.jetbrains.kotlinx.dataframe.columns.ColumnReference
+import org.jetbrains.kotlinx.dataframe.columns.ColumnSet
+import org.jetbrains.kotlinx.dataframe.columns.ColumnWithPath
+import org.jetbrains.kotlinx.dataframe.columns.ColumnsResolver
+import org.jetbrains.kotlinx.dataframe.columns.SingleColumn
+import org.jetbrains.kotlinx.dataframe.impl.columns.TransformableColumnSet
+import org.jetbrains.kotlinx.dataframe.impl.columns.transform
+import org.jetbrains.kotlinx.dataframe.impl.columns.transformSingle
+import org.jetbrains.kotlinx.dataframe.impl.headPlusArray
+import kotlin.reflect.KProperty
+
+/**
+ * ## Cols [Columns Selection DSL][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl]
+ *
+ * See [Grammar] for all functions in this interface.
+ * @param _UNUSED [#KT-68546](https://youtrack.jetbrains.com/issue/KT-68546/Conflicting-overloads-in-non-generic-interface-K2-2.0.0)
+ */
+public interface ColsColumnsSelectionDsl<out _UNUSED> {
+
+    /**
+     * ## Cols Grammar
+     *
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * [(What is this notation?)][org.jetbrains.kotlinx.dataframe.documentation.DslGrammar]
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  ### Definitions:
+     *  `columnSet: `[`ColumnSet`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]`<*>`
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  `columnGroup: `[`SingleColumn`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]`<`[`DataRow`][org.jetbrains.kotlinx.dataframe.DataRow]`<*>> | `[`String`][String]`  |  `[`KProperty`][kotlin.reflect.KProperty]`<* | `[`DataRow`][org.jetbrains.kotlinx.dataframe.DataRow]`<*>> | `[`ColumnPath`][org.jetbrains.kotlinx.dataframe.columns.ColumnPath]
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  `column: `[`ColumnAccessor`][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor]`  |  `[`String`][String]`  | `[`KProperty`][kotlin.reflect.KProperty]`<*> | `[`ColumnPath`][org.jetbrains.kotlinx.dataframe.columns.ColumnPath]
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  `index: `[`Int`][Int]
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  `condition: `[`ColumnFilter`][org.jetbrains.kotlinx.dataframe.ColumnFilter]
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  `T: Column type`
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  `indexRange: `[`IntRange`][IntRange]
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  ### What can be called directly in the [Columns Selection DSL][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl]:
+     *
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  [**`cols`**][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`[`**`<`**[`T`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ColumnTypeDef]**`>`**`]`**`(`**[`column`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ColumnDef]**`,`**`  .. |  `[`index`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.IndexDef]**`,`**`  .. |  `[`indexRange`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.IndexRangeDef]**`)`**
+     *
+     *  `| `[**`cols`**][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`  [  `**`  {  `**[`condition`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ConditionDef]**`  }  `**`]`
+     *
+     *  `| `**`this`**`/`**`it `**[**`[`**][cols]**`{ `**[`condition`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ConditionDef]**` }`**[**`]`**][cols]
+     *
+     *  `| `**`this`**`/`**`it `**[**`[`**][cols][`column`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ColumnDef]**`,`**`  ..  `[**`]`**][cols]
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  ### What can be called on a [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]:
+     *
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  [`columnSet`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ColumnSetDef]
+     *
+     *  &nbsp;&nbsp;&nbsp;&nbsp;__`.`__[**`cols`**][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]**`(`**[`index`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.IndexDef]**`,`**`  .. |  `[`indexRange`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.IndexRangeDef]**`)`**
+     *
+     *  &nbsp;&nbsp;&nbsp;&nbsp;`| `__`.`__[**`cols`**][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`  [  `**`  {  `**[`condition`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ConditionDef]**`  }  `**`]`
+     *
+     *  &nbsp;&nbsp;&nbsp;&nbsp;`| `[**`[`**][cols]**`{ `**[`condition`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ConditionDef]**` }`**[**`]`**][cols]
+     *
+     *  &nbsp;&nbsp;&nbsp;&nbsp;`| `[**`[`**][cols][`index`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.IndexDef]**`,`**`  .. |  `[`indexRange`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.IndexRangeDef][**`]`**][cols]`
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  ### What can be called on a [Column Group (reference)][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ColumnGroupDef]:
+     *
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  [`columnGroup`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ColumnGroupDef]
+     *
+     *  &nbsp;&nbsp;&nbsp;&nbsp;__`.`__[**`cols`**][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`[`**`<`**[`T`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ColumnTypeDef]**`>`**`]`**`(`**[`column`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ColumnDef]**`,`**`  .. |  `[`index`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.IndexDef]**`,`**`  .. |  `[`indexRange`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.IndexRangeDef]**`)`**
+     *
+     *  &nbsp;&nbsp;&nbsp;&nbsp;`| `__`.`__[**`cols`**][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`  [  `**`  {  `**[`condition`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ConditionDef]**`  }  `**`]`
+     *
+     *  &nbsp;&nbsp;&nbsp;&nbsp;`| `[**`[`**][cols]**`{ `**[`condition`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ConditionDef]**` }`**[**`]`**][cols]
+     *
+     *  &nbsp;&nbsp;&nbsp;&nbsp;`| `[**`[`**][cols][`column`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ColumnDef]**`,`**` ..`[**`]`**][cols]
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     */
+    public interface Grammar {
+
+        /** [**`cols`**][ColumnsSelectionDsl.cols] */
+        public interface PlainDslName
+
+        /** __`.`__[**`cols`**][ColumnsSelectionDsl.cols] */
+        public interface ColumnSetName
+
+        /** __`.`__[**`cols`**][ColumnsSelectionDsl.cols] */
+        public interface ColumnGroupName
+    }
+
+    /**
+     * ## Cols
+     * Creates a subset of columns ([ColumnSet]) from [this].
+     *
+     * You can use either a [ColumnFilter], or any of the `vararg` overloads for any
+     * [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]. The function can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index (range)).
+     *
+     * This function operates solely on columns at the top-level.
+     *
+     * Aside from calling [cols] directly, you can also use the [`get`][ColumnSet.get] operator in most cases.
+     *
+     * ### Check out: [Grammar]
+     *
+     * #### For example:
+     * `df.`[`remove`][DataFrame.remove]`  {  `[`cols`][ColumnsSelectionDsl.cols]` { it.`[`hasNulls`][DataColumn.hasNulls]`() } }`
+     *
+     * `df.`[`select`][DataFrame.select]` { myGroupCol.`[`cols`][SingleColumn.cols]`(columnA, columnB) }`
+     *
+     * `df.`[`select`][DataFrame.select]`  {  `[`colsOf`][ColumnsSelectionDsl.colsOf]`<`[`String`][String]`>()`[`[`][ColumnSet.cols]`1, 3, 5`[`]`][ColumnSet.cols]` }`
+     *
+     * #### Examples for this overload:
+     *
+     *
+     *
+     */
+    private interface CommonColsDocs {
+
+        /**
+         * ## Cols
+         * Creates a subset of columns ([ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]) from [this].
+         *
+         * You can use either a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter], or any of the `vararg` overloads for any
+         * [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]. The function can be both typed and untyped (in case you're supplying
+         * a column name, -path, or index (range)).
+         *
+         * This function operates solely on columns at the top-level.
+         *
+         * Aside from calling [cols][org.jetbrains.kotlinx.dataframe.api.ColsColumnsSelectionDsl.cols] directly, you can also use the [`get`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.get] operator in most cases.
+         *
+         * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColsColumnsSelectionDsl.Grammar]
+         *
+         * #### For example:
+         * `df.`[`remove`][org.jetbrains.kotlinx.dataframe.DataFrame.remove]`  {  `[`cols`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]` { it.`[`hasNulls`][org.jetbrains.kotlinx.dataframe.DataColumn.hasNulls]`() } }`
+         *
+         * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myGroupCol.`[`cols`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.cols]`(columnA, columnB) }`
+         *
+         * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[`colsOf`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[`String`][String]`>()`[`[`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.cols]`1, 3, 5`[`]`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.cols]` }`
+         *
+         * #### Examples for this overload:
+         *
+         *
+         *
+         *
+         * #### Filter vs. Cols:
+         * If used with a [predicate], `cols {}` functions exactly like [`filter {}`][ColumnsSelectionDsl.filter].
+         * This is intentional, however; it is recommended to use `filter {}` on [ColumnSets][ColumnSet] and
+         * `cols {}` on the rest.
+         *
+         * @param [predicate] A [ColumnFilter function][ColumnFilter] that takes a [ColumnReference] and returns a [Boolean].
+         * @return A [ColumnSet] containing the columns that match the given [predicate].
+         * @see [ColumnsSelectionDsl.filter]
+         * @see [ColumnsSelectionDsl.colsOfKind]
+         * @see [ColumnsSelectionDsl.valueCols]
+         * @see [ColumnsSelectionDsl.frameCols]
+         * @see [ColumnsSelectionDsl.colGroups]
+         */
+        interface Predicate
+
+        /**
+         * ## Cols
+         * Creates a subset of columns ([ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]) from [this].
+         *
+         * You can use either a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter], or any of the `vararg` overloads for any
+         * [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]. The function can be both typed and untyped (in case you're supplying
+         * a column name, -path, or index (range)).
+         *
+         * This function operates solely on columns at the top-level.
+         *
+         * Aside from calling [cols][org.jetbrains.kotlinx.dataframe.api.ColsColumnsSelectionDsl.cols] directly, you can also use the [`get`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.get] operator in most cases.
+         *
+         * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColsColumnsSelectionDsl.Grammar]
+         *
+         * #### For example:
+         * `df.`[`remove`][org.jetbrains.kotlinx.dataframe.DataFrame.remove]`  {  `[`cols`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]` { it.`[`hasNulls`][org.jetbrains.kotlinx.dataframe.DataColumn.hasNulls]`() } }`
+         *
+         * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myGroupCol.`[`cols`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.cols]`(columnA, columnB) }`
+         *
+         * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[`colsOf`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[`String`][String]`>()`[`[`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.cols]`1, 3, 5`[`]`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.cols]` }`
+         *
+         * #### Examples for this overload:
+         *
+         *
+         *
+         *
+         * @param [firstCol] A  that points to a relative column.
+         * @param [otherCols] Optional additional s that point to relative columns.
+         * @throws [IllegalArgumentException] if any of the given [ColumnReference]s point to a column that doesn't
+         *   exist.
+         * @return A [ColumnSet] containing the columns that [firstCol] and [otherCols] point to.
+         */
+        interface Vararg {
+
+            interface AccessorType
+        }
+
+        /** Example argument */
+        interface Examples
+    }
+
+    /**
+     * ## Cols: Columns by Indices
+     *
+     * Retrieves one or multiple columns from [this] in the form of a [ColumnSet] by their indices.
+     * If any of the indices are out of bounds, an [IndexOutOfBoundsException] is thrown.
+     *
+     * ### Check out: [Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[`select`][DataFrame.select]`  {  `[`cols`][SingleColumn.cols]`(1, 3, 2) }`
+     *
+     * `df.`[`select`][DataFrame.select]`  {  `[`colsOf`][ColumnsSelectionDsl.colsOf]`<`[`Int`][Int]`>()`[`[`][SingleColumn.get]`5, 1, 2`[`]`][SingleColumn.get]` }`
+     *
+     * `df.`[`select`][DataFrame.select]` { "myColumnGroup".`[`cols`][String.cols]`(0, 2) }`
+     *
+     * #### Examples for this overload:
+     *
+     *
+     *
+     * @throws [IndexOutOfBoundsException] If any index is out of bounds.
+     * @param [firstIndex] The index of the first column to retrieve.
+     * @param [otherIndices] The other indices of the columns to retrieve.
+     * @return A [ColumnSet] containing the columns found at the given indices.
+     */
+    private interface CommonColsIndicesDocs {
+
+        /** Example argument */
+        interface ExampleArg
+    }
+
+    /**
+     * ## Cols: Columns by Index Range
+     *
+     * Retrieves multiple columns from [this] in the form of a [ColumnSet] by a [range] of indices.
+     * If any of the indices in the [range] are out of bounds, an [IndexOutOfBoundsException] is thrown.
+     *
+     * ### Check out: [Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[`select`][DataFrame.select]`  {  `[`cols`][SingleColumn.cols]`(1`[`..`][Int.rangeTo]`3) }`
+     *
+     * `df.`[`select`][DataFrame.select]`  {  `[`colsOf`][ColumnsSelectionDsl.colsOf]`<`[`Int`][Int]`>()`[`[`][ColumnSet.cols]`1`[`..`][Int.rangeTo]`5`[`]`][ColumnSet.cols]` }`
+     *
+     * `df.`[`select`][DataFrame.select]` { "myColGroup".`[`cols`][String.cols]`(0`[`..`][Int.rangeTo]`2) }`
+     *
+     * #### Examples for this overload:
+     *
+     *
+     *
+     * @throws [IndexOutOfBoundsException] if any of the indices in the [range] are out of bounds.
+     * @throws [IllegalArgumentException] if the [range] is empty.
+     * @param [range] The range of indices to retrieve in the form of an [IntRange].
+     * @return A [ColumnSet] containing the columns found at the given indices.
+     */
+    private interface CommonColsRangeDocs {
+
+        /** Example argument */
+        interface ExampleArg
+    }
+
+    // region predicate
+
+    /**
+     * ## Cols
+     * Creates a subset of columns ([ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]) from [this].
+     *
+     * You can use either a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter], or any of the `vararg` overloads for any
+     * [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]. The function can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index (range)).
+     *
+     * This function operates solely on columns at the top-level.
+     *
+     * Aside from calling [cols][org.jetbrains.kotlinx.dataframe.api.ColsColumnsSelectionDsl.cols] directly, you can also use the [`get`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.get] operator in most cases.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColsColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     * `df.`[`remove`][org.jetbrains.kotlinx.dataframe.DataFrame.remove]`  {  `[`cols`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]` { it.`[`hasNulls`][org.jetbrains.kotlinx.dataframe.DataColumn.hasNulls]`() } }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myGroupCol.`[`cols`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.cols]`(columnA, columnB) }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[`colsOf`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[`String`][String]`>()`[`[`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.cols]`1, 3, 5`[`]`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.cols]` }`
+     *
+     * #### Examples for this overload:
+     *
+     * `// although these can be shortened to just the `[`colsOf<>{ }`][ColumnsSelectionDsl.colsOf]` call`
+     *
+     * `df.`[`select`][DataFrame.select]`  {  `[`colsOf`][ColumnsSelectionDsl.colsOf]`<`[`String`][String]`>().`[`cols`][ColumnSet.cols]`  { "e"  `[`in`][String.contains]` it.`[`name`][ColumnPath.name]`() } }`
+     *
+     * `df.`[`select`][DataFrame.select]`  {  `[`colsOf`][ColumnsSelectionDsl.colsOf]`<`[`String`][String]`>()`[`[`][ColumnSet.cols]`{ it.`[`any`][ColumnWithPath.any]` { it == "Alice" } }`[`]`][ColumnSet.cols]` }`
+     *
+     * `// identity call, same as `[`all`][ColumnsSelectionDsl.all]`()`
+     *
+     * `df.`[`select`][DataFrame.select]`  {  `[`colsOf`][ColumnsSelectionDsl.colsOf]`<`[`String`][String]`>().`[`cols`][ColumnSet.cols]`() }`
+     *
+     *
+     * #### Filter vs. Cols:
+     * If used with a [predicate], `cols {}` functions exactly like [`filter {}`][org.jetbrains.kotlinx.dataframe.api.FilterColumnsSelectionDsl.filter].
+     * This is intentional, however; it is recommended to use `filter {}` on [ColumnSets][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] and
+     * `cols {}` on the rest.
+     *
+     * @param [predicate] A [ColumnFilter function][org.jetbrains.kotlinx.dataframe.ColumnFilter] that takes a [ColumnReference][org.jetbrains.kotlinx.dataframe.columns.ColumnReference] and returns a [Boolean].
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing the columns that match the given [predicate].
+     * @see [ColumnsSelectionDsl.filter]
+     * @see [ColumnsSelectionDsl.colsOfKind]
+     * @see [ColumnsSelectionDsl.valueCols]
+     * @see [ColumnsSelectionDsl.frameCols]
+     * @see [ColumnsSelectionDsl.colGroups]
+     * @see [ColumnsSelectionDsl.all]
+     * @see [ColumnsSelectionDsl.filter]
+     */
+    private interface ColumnSetColsPredicateDocs
+
+    /** ## Cols
+     * Creates a subset of columns ([ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]) from [this].
+     *
+     * You can use either a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter], or any of the `vararg` overloads for any
+     * [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]. The function can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index (range)).
+     *
+     * This function operates solely on columns at the top-level.
+     *
+     * Aside from calling [cols][org.jetbrains.kotlinx.dataframe.api.ColsColumnsSelectionDsl.cols] directly, you can also use the [`get`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.get] operator in most cases.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColsColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     * `df.`[`remove`][org.jetbrains.kotlinx.dataframe.DataFrame.remove]`  {  `[`cols`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]` { it.`[`hasNulls`][org.jetbrains.kotlinx.dataframe.DataColumn.hasNulls]`() } }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myGroupCol.`[`cols`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.cols]`(columnA, columnB) }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[`colsOf`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[`String`][String]`>()`[`[`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.cols]`1, 3, 5`[`]`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.cols]` }`
+     *
+     * #### Examples for this overload:
+     *
+     * `// although these can be shortened to just the `[`colsOf<>{ }`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]` call`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[`colsOf`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[`String`][String]`>().`[`cols`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.cols]`  { "e"  `[`in`][String.contains]` it.`[`name`][org.jetbrains.kotlinx.dataframe.columns.ColumnPath.name]`() } }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[`colsOf`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[`String`][String]`>()`[`[`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.cols]`{ it.`[`any`][org.jetbrains.kotlinx.dataframe.DataColumn.any]` { it == "Alice" } }`[`]`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.cols]` }`
+     *
+     * `// identity call, same as `[`all`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.all]`()`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[`colsOf`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[`String`][String]`>().`[`cols`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.cols]`() }`
+     *
+     *
+     * #### Filter vs. Cols:
+     * If used with a [predicate], `cols {}` functions exactly like [`filter {}`][org.jetbrains.kotlinx.dataframe.api.FilterColumnsSelectionDsl.filter].
+     * This is intentional, however; it is recommended to use `filter {}` on [ColumnSets][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] and
+     * `cols {}` on the rest.
+     *
+     * @param [predicate] A [ColumnFilter function][org.jetbrains.kotlinx.dataframe.ColumnFilter] that takes a [ColumnReference][org.jetbrains.kotlinx.dataframe.columns.ColumnReference] and returns a [Boolean].
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing the columns that match the given [predicate].
+     * @see [ColumnsSelectionDsl.filter]
+     * @see [ColumnsSelectionDsl.colsOfKind]
+     * @see [ColumnsSelectionDsl.valueCols]
+     * @see [ColumnsSelectionDsl.frameCols]
+     * @see [ColumnsSelectionDsl.colGroups]
+     * @see [ColumnsSelectionDsl.all]
+     * @see [ColumnsSelectionDsl.filter] */
+    @Suppress("UNCHECKED_CAST")
+    public fun <C> ColumnSet<C>.cols(predicate: ColumnFilter<C> = { true }): TransformableColumnSet<C> =
+        colsInternal(predicate as ColumnFilter<*>) as TransformableColumnSet<C>
+
+    /** ## Cols
+     * Creates a subset of columns ([ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]) from [this].
+     *
+     * You can use either a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter], or any of the `vararg` overloads for any
+     * [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]. The function can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index (range)).
+     *
+     * This function operates solely on columns at the top-level.
+     *
+     * Aside from calling [cols][org.jetbrains.kotlinx.dataframe.api.ColsColumnsSelectionDsl.cols] directly, you can also use the [`get`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.get] operator in most cases.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColsColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     * `df.`[`remove`][org.jetbrains.kotlinx.dataframe.DataFrame.remove]`  {  `[`cols`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]` { it.`[`hasNulls`][org.jetbrains.kotlinx.dataframe.DataColumn.hasNulls]`() } }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myGroupCol.`[`cols`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.cols]`(columnA, columnB) }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[`colsOf`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[`String`][String]`>()`[`[`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.cols]`1, 3, 5`[`]`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.cols]` }`
+     *
+     * #### Examples for this overload:
+     *
+     * `// although these can be shortened to just the `[`colsOf<>{ }`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]` call`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[`colsOf`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[`String`][String]`>().`[`cols`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.cols]`  { "e"  `[`in`][String.contains]` it.`[`name`][org.jetbrains.kotlinx.dataframe.columns.ColumnPath.name]`() } }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[`colsOf`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[`String`][String]`>()`[`[`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.cols]`{ it.`[`any`][org.jetbrains.kotlinx.dataframe.DataColumn.any]` { it == "Alice" } }`[`]`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.cols]` }`
+     *
+     * `// identity call, same as `[`all`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.all]`()`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[`colsOf`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[`String`][String]`>().`[`cols`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.cols]`() }`
+     *
+     *
+     * #### Filter vs. Cols:
+     * If used with a [predicate], `cols {}` functions exactly like [`filter {}`][org.jetbrains.kotlinx.dataframe.api.FilterColumnsSelectionDsl.filter].
+     * This is intentional, however; it is recommended to use `filter {}` on [ColumnSets][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] and
+     * `cols {}` on the rest.
+     *
+     * @param [predicate] A [ColumnFilter function][org.jetbrains.kotlinx.dataframe.ColumnFilter] that takes a [ColumnReference][org.jetbrains.kotlinx.dataframe.columns.ColumnReference] and returns a [Boolean].
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing the columns that match the given [predicate].
+     * @see [ColumnsSelectionDsl.filter]
+     * @see [ColumnsSelectionDsl.colsOfKind]
+     * @see [ColumnsSelectionDsl.valueCols]
+     * @see [ColumnsSelectionDsl.frameCols]
+     * @see [ColumnsSelectionDsl.colGroups]
+     * @see [ColumnsSelectionDsl.all]
+     * @see [ColumnsSelectionDsl.filter] */
+    public operator fun <C> ColumnSet<C>.get(predicate: ColumnFilter<C> = { true }): TransformableColumnSet<C> =
+        cols(predicate)
+
+    /**
+     * ## Cols
+     * Creates a subset of columns ([ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]) from [this].
+     *
+     * You can use either a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter], or any of the `vararg` overloads for any
+     * [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]. The function can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index (range)).
+     *
+     * This function operates solely on columns at the top-level.
+     *
+     * Aside from calling [cols][org.jetbrains.kotlinx.dataframe.api.ColsColumnsSelectionDsl.cols] directly, you can also use the [`get`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.get] operator in most cases.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColsColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     * `df.`[`remove`][org.jetbrains.kotlinx.dataframe.DataFrame.remove]`  {  `[`cols`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]` { it.`[`hasNulls`][org.jetbrains.kotlinx.dataframe.DataColumn.hasNulls]`() } }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myGroupCol.`[`cols`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.cols]`(columnA, columnB) }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[`colsOf`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[`String`][String]`>()`[`[`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.cols]`1, 3, 5`[`]`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.cols]` }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[`select`][DataFrame.select]`  {  `[`cols`][ColumnsSelectionDsl.cols]`  { "e"  `[`in`][String.contains]` it.`[`name`][ColumnPath.name]`() } }`
+     *
+     * `df.`[`select`][DataFrame.select]` { this`[`[`][ColumnsSelectionDsl.cols]`{ it.`[`any`][ColumnWithPath.any]` { it == "Alice" } }`[`]`][ColumnsSelectionDsl.cols]` }`
+     *
+     * `// same as `[`all`][ColumnsSelectionDsl.all]`()`
+     *
+     * `df.`[`select`][DataFrame.select]`  {  `[`cols`][ColumnsSelectionDsl.cols]`() }`
+     *
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     *
+     * #### Filter vs. Cols:
+     * If used with a [predicate], `cols {}` functions exactly like [`filter {}`][org.jetbrains.kotlinx.dataframe.api.FilterColumnsSelectionDsl.filter].
+     * This is intentional, however; it is recommended to use `filter {}` on [ColumnSets][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] and
+     * `cols {}` on the rest.
+     *
+     * @param [predicate] A [ColumnFilter function][org.jetbrains.kotlinx.dataframe.ColumnFilter] that takes a [ColumnReference][org.jetbrains.kotlinx.dataframe.columns.ColumnReference] and returns a [Boolean].
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing the columns that match the given [predicate].
+     * @see [ColumnsSelectionDsl.filter]
+     * @see [ColumnsSelectionDsl.colsOfKind]
+     * @see [ColumnsSelectionDsl.valueCols]
+     * @see [ColumnsSelectionDsl.frameCols]
+     * @see [ColumnsSelectionDsl.colGroups]
+     * @see [ColumnsSelectionDsl.all]
+     */
+    private interface ColumnsSelectionDslColsPredicateDocs
+
+    /** ## Cols
+     * Creates a subset of columns ([ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]) from [this].
+     *
+     * You can use either a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter], or any of the `vararg` overloads for any
+     * [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]. The function can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index (range)).
+     *
+     * This function operates solely on columns at the top-level.
+     *
+     * Aside from calling [cols][org.jetbrains.kotlinx.dataframe.api.ColsColumnsSelectionDsl.cols] directly, you can also use the [`get`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.get] operator in most cases.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColsColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     * `df.`[`remove`][org.jetbrains.kotlinx.dataframe.DataFrame.remove]`  {  `[`cols`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]` { it.`[`hasNulls`][org.jetbrains.kotlinx.dataframe.DataColumn.hasNulls]`() } }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myGroupCol.`[`cols`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.cols]`(columnA, columnB) }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[`colsOf`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[`String`][String]`>()`[`[`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.cols]`1, 3, 5`[`]`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.cols]` }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[`cols`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`  { "e"  `[`in`][String.contains]` it.`[`name`][org.jetbrains.kotlinx.dataframe.columns.ColumnPath.name]`() } }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { this`[`[`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`{ it.`[`any`][org.jetbrains.kotlinx.dataframe.DataColumn.any]` { it == "Alice" } }`[`]`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]` }`
+     *
+     * `// same as `[`all`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.all]`()`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[`cols`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`() }`
+     *
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     *
+     * #### Filter vs. Cols:
+     * If used with a [predicate], `cols {}` functions exactly like [`filter {}`][org.jetbrains.kotlinx.dataframe.api.FilterColumnsSelectionDsl.filter].
+     * This is intentional, however; it is recommended to use `filter {}` on [ColumnSets][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] and
+     * `cols {}` on the rest.
+     *
+     * @param [predicate] A [ColumnFilter function][org.jetbrains.kotlinx.dataframe.ColumnFilter] that takes a [ColumnReference][org.jetbrains.kotlinx.dataframe.columns.ColumnReference] and returns a [Boolean].
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing the columns that match the given [predicate].
+     * @see [ColumnsSelectionDsl.filter]
+     * @see [ColumnsSelectionDsl.colsOfKind]
+     * @see [ColumnsSelectionDsl.valueCols]
+     * @see [ColumnsSelectionDsl.frameCols]
+     * @see [ColumnsSelectionDsl.colGroups]
+     * @see [ColumnsSelectionDsl.all] */
+    public fun ColumnsSelectionDsl<*>.cols(predicate: ColumnFilter<*> = { true }): TransformableColumnSet<*> =
+        this.asSingleColumn().colsInternal(predicate)
+
+    /** ## Cols
+     * Creates a subset of columns ([ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]) from [this].
+     *
+     * You can use either a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter], or any of the `vararg` overloads for any
+     * [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]. The function can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index (range)).
+     *
+     * This function operates solely on columns at the top-level.
+     *
+     * Aside from calling [cols][org.jetbrains.kotlinx.dataframe.api.ColsColumnsSelectionDsl.cols] directly, you can also use the [`get`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.get] operator in most cases.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColsColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     * `df.`[`remove`][org.jetbrains.kotlinx.dataframe.DataFrame.remove]`  {  `[`cols`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]` { it.`[`hasNulls`][org.jetbrains.kotlinx.dataframe.DataColumn.hasNulls]`() } }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myGroupCol.`[`cols`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.cols]`(columnA, columnB) }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[`colsOf`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[`String`][String]`>()`[`[`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.cols]`1, 3, 5`[`]`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.cols]` }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[`cols`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`  { "e"  `[`in`][String.contains]` it.`[`name`][org.jetbrains.kotlinx.dataframe.columns.ColumnPath.name]`() } }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { this`[`[`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`{ it.`[`any`][org.jetbrains.kotlinx.dataframe.DataColumn.any]` { it == "Alice" } }`[`]`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]` }`
+     *
+     * `// same as `[`all`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.all]`()`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[`cols`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`() }`
+     *
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     *
+     * #### Filter vs. Cols:
+     * If used with a [predicate], `cols {}` functions exactly like [`filter {}`][org.jetbrains.kotlinx.dataframe.api.FilterColumnsSelectionDsl.filter].
+     * This is intentional, however; it is recommended to use `filter {}` on [ColumnSets][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] and
+     * `cols {}` on the rest.
+     *
+     * @param [predicate] A [ColumnFilter function][org.jetbrains.kotlinx.dataframe.ColumnFilter] that takes a [ColumnReference][org.jetbrains.kotlinx.dataframe.columns.ColumnReference] and returns a [Boolean].
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing the columns that match the given [predicate].
+     * @see [ColumnsSelectionDsl.filter]
+     * @see [ColumnsSelectionDsl.colsOfKind]
+     * @see [ColumnsSelectionDsl.valueCols]
+     * @see [ColumnsSelectionDsl.frameCols]
+     * @see [ColumnsSelectionDsl.colGroups]
+     * @see [ColumnsSelectionDsl.all] */
+    public operator fun ColumnsSelectionDsl<*>.get(predicate: ColumnFilter<*> = { true }): TransformableColumnSet<*> =
+        cols(predicate)
+
+    /**
+     * ## Cols
+     * Creates a subset of columns ([ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]) from [this].
+     *
+     * You can use either a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter], or any of the `vararg` overloads for any
+     * [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]. The function can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index (range)).
+     *
+     * This function operates solely on columns at the top-level.
+     *
+     * Aside from calling [cols][org.jetbrains.kotlinx.dataframe.api.ColsColumnsSelectionDsl.cols] directly, you can also use the [`get`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.get] operator in most cases.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColsColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     * `df.`[`remove`][org.jetbrains.kotlinx.dataframe.DataFrame.remove]`  {  `[`cols`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]` { it.`[`hasNulls`][org.jetbrains.kotlinx.dataframe.DataColumn.hasNulls]`() } }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myGroupCol.`[`cols`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.cols]`(columnA, columnB) }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[`colsOf`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[`String`][String]`>()`[`[`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.cols]`1, 3, 5`[`]`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.cols]` }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[`select`][DataFrame.select]` { myColumnGroup`.[`cols`][SingleColumn.cols]`  { "e"  `[`in`][String.contains]` it.`[`name`][ColumnPath.name]`() } }`
+     *
+     * `// same as `[`allCols`][ColumnsSelectionDsl.allCols]`()`
+     *
+     * `df.`[`select`][DataFrame.select]` { myColumnGroup.`[`cols`][SingleColumn.cols]`() }`
+     *
+     * `df.`[`select`][DataFrame.select]` { myColumnGroup`[`[`][SingleColumn.cols]`{ ... }`[`]`][SingleColumn.cols]` }`
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     *
+     * #### Filter vs. Cols:
+     * If used with a [predicate], `cols {}` functions exactly like [`filter {}`][org.jetbrains.kotlinx.dataframe.api.FilterColumnsSelectionDsl.filter].
+     * This is intentional, however; it is recommended to use `filter {}` on [ColumnSets][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] and
+     * `cols {}` on the rest.
+     *
+     * @param [predicate] A [ColumnFilter function][org.jetbrains.kotlinx.dataframe.ColumnFilter] that takes a [ColumnReference][org.jetbrains.kotlinx.dataframe.columns.ColumnReference] and returns a [Boolean].
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing the columns that match the given [predicate].
+     * @see [ColumnsSelectionDsl.filter]
+     * @see [ColumnsSelectionDsl.colsOfKind]
+     * @see [ColumnsSelectionDsl.valueCols]
+     * @see [ColumnsSelectionDsl.frameCols]
+     * @see [ColumnsSelectionDsl.colGroups]
+     * @see [ColumnsSelectionDsl.allCols]
+     */
+    private interface SingleColumnAnyRowColsPredicateDocs
+
+    /** ## Cols
+     * Creates a subset of columns ([ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]) from [this].
+     *
+     * You can use either a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter], or any of the `vararg` overloads for any
+     * [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]. The function can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index (range)).
+     *
+     * This function operates solely on columns at the top-level.
+     *
+     * Aside from calling [cols][org.jetbrains.kotlinx.dataframe.api.ColsColumnsSelectionDsl.cols] directly, you can also use the [`get`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.get] operator in most cases.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColsColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     * `df.`[`remove`][org.jetbrains.kotlinx.dataframe.DataFrame.remove]`  {  `[`cols`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]` { it.`[`hasNulls`][org.jetbrains.kotlinx.dataframe.DataColumn.hasNulls]`() } }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myGroupCol.`[`cols`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.cols]`(columnA, columnB) }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[`colsOf`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[`String`][String]`>()`[`[`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.cols]`1, 3, 5`[`]`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.cols]` }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup`.[`cols`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.cols]`  { "e"  `[`in`][String.contains]` it.`[`name`][org.jetbrains.kotlinx.dataframe.columns.ColumnPath.name]`() } }`
+     *
+     * `// same as `[`allCols`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allCols]`()`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[`cols`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.cols]`() }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup`[`[`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.cols]`{ ... }`[`]`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.cols]` }`
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     *
+     * #### Filter vs. Cols:
+     * If used with a [predicate], `cols {}` functions exactly like [`filter {}`][org.jetbrains.kotlinx.dataframe.api.FilterColumnsSelectionDsl.filter].
+     * This is intentional, however; it is recommended to use `filter {}` on [ColumnSets][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] and
+     * `cols {}` on the rest.
+     *
+     * @param [predicate] A [ColumnFilter function][org.jetbrains.kotlinx.dataframe.ColumnFilter] that takes a [ColumnReference][org.jetbrains.kotlinx.dataframe.columns.ColumnReference] and returns a [Boolean].
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing the columns that match the given [predicate].
+     * @see [ColumnsSelectionDsl.filter]
+     * @see [ColumnsSelectionDsl.colsOfKind]
+     * @see [ColumnsSelectionDsl.valueCols]
+     * @see [ColumnsSelectionDsl.frameCols]
+     * @see [ColumnsSelectionDsl.colGroups]
+     * @see [ColumnsSelectionDsl.allCols] */
+    public fun SingleColumn<DataRow<*>>.cols(predicate: ColumnFilter<*> = { true }): TransformableColumnSet<*> =
+        this.ensureIsColumnGroup().colsInternal(predicate)
+
+    /**
+     * ## Cols
+     * Creates a subset of columns ([ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]) from [this].
+     *
+     * You can use either a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter], or any of the `vararg` overloads for any
+     * [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]. The function can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index (range)).
+     *
+     * This function operates solely on columns at the top-level.
+     *
+     * Aside from calling [cols][org.jetbrains.kotlinx.dataframe.api.ColsColumnsSelectionDsl.cols] directly, you can also use the [`get`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.get] operator in most cases.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColsColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     * `df.`[`remove`][org.jetbrains.kotlinx.dataframe.DataFrame.remove]`  {  `[`cols`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]` { it.`[`hasNulls`][org.jetbrains.kotlinx.dataframe.DataColumn.hasNulls]`() } }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myGroupCol.`[`cols`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.cols]`(columnA, columnB) }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[`colsOf`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[`String`][String]`>()`[`[`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.cols]`1, 3, 5`[`]`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.cols]` }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup`.[`cols`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.cols]`  { "e"  `[`in`][String.contains]` it.`[`name`][org.jetbrains.kotlinx.dataframe.columns.ColumnPath.name]`() } }`
+     *
+     * `// same as `[`allCols`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allCols]`()`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[`cols`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.cols]`() }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup`[`[`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.cols]`{ ... }`[`]`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.cols]` }`
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     *
+     * #### Filter vs. Cols:
+     * If used with a [predicate], `cols {}` functions exactly like [`filter {}`][org.jetbrains.kotlinx.dataframe.api.FilterColumnsSelectionDsl.filter].
+     * This is intentional, however; it is recommended to use `filter {}` on [ColumnSets][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] and
+     * `cols {}` on the rest.
+     *
+     * @param [predicate] A [ColumnFilter function][org.jetbrains.kotlinx.dataframe.ColumnFilter] that takes a [ColumnReference][org.jetbrains.kotlinx.dataframe.columns.ColumnReference] and returns a [Boolean].
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing the columns that match the given [predicate].
+     * @see [ColumnsSelectionDsl.filter]
+     * @see [ColumnsSelectionDsl.colsOfKind]
+     * @see [ColumnsSelectionDsl.valueCols]
+     * @see [ColumnsSelectionDsl.frameCols]
+     * @see [ColumnsSelectionDsl.colGroups]
+     * @see [ColumnsSelectionDsl.allCols]
+     */
+    public operator fun SingleColumn<DataRow<*>>.get(
+        predicate: ColumnFilter<*> = { true },
+    ): TransformableColumnSet<*> = cols(predicate)
+
+    /**
+     * ## Cols
+     * Creates a subset of columns ([ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]) from [this].
+     *
+     * You can use either a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter], or any of the `vararg` overloads for any
+     * [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]. The function can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index (range)).
+     *
+     * This function operates solely on columns at the top-level.
+     *
+     * Aside from calling [cols][org.jetbrains.kotlinx.dataframe.api.ColsColumnsSelectionDsl.cols] directly, you can also use the [`get`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.get] operator in most cases.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColsColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     * `df.`[`remove`][org.jetbrains.kotlinx.dataframe.DataFrame.remove]`  {  `[`cols`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]` { it.`[`hasNulls`][org.jetbrains.kotlinx.dataframe.DataColumn.hasNulls]`() } }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myGroupCol.`[`cols`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.cols]`(columnA, columnB) }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[`colsOf`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[`String`][String]`>()`[`[`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.cols]`1, 3, 5`[`]`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.cols]` }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[`select`][DataFrame.select]` { "myGroupCol".`[`cols`][String.cols]`  { "e"  `[`in`][String.contains]` it.`[`name`][ColumnPath.name]`() } }`
+     *
+     * `df.`[`select`][DataFrame.select]` { "myGroupCol"`[`[`][String.cols]`{ it.`[`any`][ColumnWithPath.any]` { it == "Alice" } }`[`]`][String.cols]` }`
+     *
+     * `// same as `[`allCols`][ColumnsSelectionDsl.allCols]`()`
+     *
+     * `df.`[`select`][DataFrame.select]` { "myGroupCol".`[`cols`][String.cols]`() }`
+     *
+     *
+     * #### Filter vs. Cols:
+     * If used with a [predicate], `cols {}` functions exactly like [`filter {}`][org.jetbrains.kotlinx.dataframe.api.FilterColumnsSelectionDsl.filter].
+     * This is intentional, however; it is recommended to use `filter {}` on [ColumnSets][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] and
+     * `cols {}` on the rest.
+     *
+     * @param [predicate] A [ColumnFilter function][org.jetbrains.kotlinx.dataframe.ColumnFilter] that takes a [ColumnReference][org.jetbrains.kotlinx.dataframe.columns.ColumnReference] and returns a [Boolean].
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing the columns that match the given [predicate].
+     * @see [ColumnsSelectionDsl.filter]
+     * @see [ColumnsSelectionDsl.colsOfKind]
+     * @see [ColumnsSelectionDsl.valueCols]
+     * @see [ColumnsSelectionDsl.frameCols]
+     * @see [ColumnsSelectionDsl.colGroups]
+     */
+    private interface StringColsPredicateDocs
+
+    /** ## Cols
+     * Creates a subset of columns ([ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]) from [this].
+     *
+     * You can use either a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter], or any of the `vararg` overloads for any
+     * [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]. The function can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index (range)).
+     *
+     * This function operates solely on columns at the top-level.
+     *
+     * Aside from calling [cols][org.jetbrains.kotlinx.dataframe.api.ColsColumnsSelectionDsl.cols] directly, you can also use the [`get`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.get] operator in most cases.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColsColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     * `df.`[`remove`][org.jetbrains.kotlinx.dataframe.DataFrame.remove]`  {  `[`cols`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]` { it.`[`hasNulls`][org.jetbrains.kotlinx.dataframe.DataColumn.hasNulls]`() } }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myGroupCol.`[`cols`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.cols]`(columnA, columnB) }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[`colsOf`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[`String`][String]`>()`[`[`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.cols]`1, 3, 5`[`]`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.cols]` }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "myGroupCol".`[`cols`][kotlin.String.cols]`  { "e"  `[`in`][String.contains]` it.`[`name`][org.jetbrains.kotlinx.dataframe.columns.ColumnPath.name]`() } }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "myGroupCol"`[`[`][kotlin.String.cols]`{ it.`[`any`][org.jetbrains.kotlinx.dataframe.DataColumn.any]` { it == "Alice" } }`[`]`][kotlin.String.cols]` }`
+     *
+     * `// same as `[`allCols`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allCols]`()`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "myGroupCol".`[`cols`][kotlin.String.cols]`() }`
+     *
+     *
+     * #### Filter vs. Cols:
+     * If used with a [predicate], `cols {}` functions exactly like [`filter {}`][org.jetbrains.kotlinx.dataframe.api.FilterColumnsSelectionDsl.filter].
+     * This is intentional, however; it is recommended to use `filter {}` on [ColumnSets][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] and
+     * `cols {}` on the rest.
+     *
+     * @param [predicate] A [ColumnFilter function][org.jetbrains.kotlinx.dataframe.ColumnFilter] that takes a [ColumnReference][org.jetbrains.kotlinx.dataframe.columns.ColumnReference] and returns a [Boolean].
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing the columns that match the given [predicate].
+     * @see [ColumnsSelectionDsl.filter]
+     * @see [ColumnsSelectionDsl.colsOfKind]
+     * @see [ColumnsSelectionDsl.valueCols]
+     * @see [ColumnsSelectionDsl.frameCols]
+     * @see [ColumnsSelectionDsl.colGroups]
+     */
+    public fun String.cols(predicate: ColumnFilter<*> = { true }): TransformableColumnSet<*> =
+        columnGroup(this).cols(predicate)
+
+    /** ## Cols
+     * Creates a subset of columns ([ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]) from [this].
+     *
+     * You can use either a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter], or any of the `vararg` overloads for any
+     * [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]. The function can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index (range)).
+     *
+     * This function operates solely on columns at the top-level.
+     *
+     * Aside from calling [cols][org.jetbrains.kotlinx.dataframe.api.ColsColumnsSelectionDsl.cols] directly, you can also use the [`get`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.get] operator in most cases.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColsColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     * `df.`[`remove`][org.jetbrains.kotlinx.dataframe.DataFrame.remove]`  {  `[`cols`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]` { it.`[`hasNulls`][org.jetbrains.kotlinx.dataframe.DataColumn.hasNulls]`() } }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myGroupCol.`[`cols`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.cols]`(columnA, columnB) }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[`colsOf`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[`String`][String]`>()`[`[`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.cols]`1, 3, 5`[`]`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.cols]` }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "myGroupCol".`[`cols`][kotlin.String.cols]`  { "e"  `[`in`][String.contains]` it.`[`name`][org.jetbrains.kotlinx.dataframe.columns.ColumnPath.name]`() } }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "myGroupCol"`[`[`][kotlin.String.cols]`{ it.`[`any`][org.jetbrains.kotlinx.dataframe.DataColumn.any]` { it == "Alice" } }`[`]`][kotlin.String.cols]` }`
+     *
+     * `// same as `[`allCols`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allCols]`()`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "myGroupCol".`[`cols`][kotlin.String.cols]`() }`
+     *
+     *
+     * #### Filter vs. Cols:
+     * If used with a [predicate], `cols {}` functions exactly like [`filter {}`][org.jetbrains.kotlinx.dataframe.api.FilterColumnsSelectionDsl.filter].
+     * This is intentional, however; it is recommended to use `filter {}` on [ColumnSets][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] and
+     * `cols {}` on the rest.
+     *
+     * @param [predicate] A [ColumnFilter function][org.jetbrains.kotlinx.dataframe.ColumnFilter] that takes a [ColumnReference][org.jetbrains.kotlinx.dataframe.columns.ColumnReference] and returns a [Boolean].
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing the columns that match the given [predicate].
+     * @see [ColumnsSelectionDsl.filter]
+     * @see [ColumnsSelectionDsl.colsOfKind]
+     * @see [ColumnsSelectionDsl.valueCols]
+     * @see [ColumnsSelectionDsl.frameCols]
+     * @see [ColumnsSelectionDsl.colGroups]
+     */
+    public operator fun String.get(predicate: ColumnFilter<*> = { true }): TransformableColumnSet<*> = cols(predicate)
+
+    /**
+     * ## Cols
+     * Creates a subset of columns ([ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]) from [this].
+     *
+     * You can use either a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter], or any of the `vararg` overloads for any
+     * [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]. The function can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index (range)).
+     *
+     * This function operates solely on columns at the top-level.
+     *
+     * Aside from calling [cols][org.jetbrains.kotlinx.dataframe.api.ColsColumnsSelectionDsl.cols] directly, you can also use the [`get`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.get] operator in most cases.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColsColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     * `df.`[`remove`][org.jetbrains.kotlinx.dataframe.DataFrame.remove]`  {  `[`cols`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]` { it.`[`hasNulls`][org.jetbrains.kotlinx.dataframe.DataColumn.hasNulls]`() } }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myGroupCol.`[`cols`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.cols]`(columnA, columnB) }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[`colsOf`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[`String`][String]`>()`[`[`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.cols]`1, 3, 5`[`]`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.cols]` }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[`select`][DataFrame.select]` { Type::columnGroup.`[`cols`][KProperty.cols]`  { "e"  `[`in`][String.contains]` it.`[`name`][ColumnPath.name]`() } }`
+     *
+     * `df.`[`select`][DataFrame.select]` { Type::columnGroup`[`[`][SingleColumn.cols]`{ it.`[`any`][ColumnWithPath.any]` { it == "Alice" } }`[`]`][SingleColumn.cols]` }`
+     *
+     * `// same as `[`allCols`][ColumnsSelectionDsl.allCols]`()`
+     *
+     * `df.`[`select`][DataFrame.select]` { Type::columnGroup.`[`cols`][SingleColumn.cols]`() }`
+     *
+     *
+     * #### Filter vs. Cols:
+     * If used with a [predicate], `cols {}` functions exactly like [`filter {}`][org.jetbrains.kotlinx.dataframe.api.FilterColumnsSelectionDsl.filter].
+     * This is intentional, however; it is recommended to use `filter {}` on [ColumnSets][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] and
+     * `cols {}` on the rest.
+     *
+     * @param [predicate] A [ColumnFilter function][org.jetbrains.kotlinx.dataframe.ColumnFilter] that takes a [ColumnReference][org.jetbrains.kotlinx.dataframe.columns.ColumnReference] and returns a [Boolean].
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing the columns that match the given [predicate].
+     * @see [ColumnsSelectionDsl.filter]
+     * @see [ColumnsSelectionDsl.colsOfKind]
+     * @see [ColumnsSelectionDsl.valueCols]
+     * @see [ColumnsSelectionDsl.frameCols]
+     * @see [ColumnsSelectionDsl.colGroups]
+     * @see [ColumnsSelectionDsl.allCols]
+     */
+    private interface KPropertyColsPredicateDocs
+
+    /** ## Cols
+     * Creates a subset of columns ([ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]) from [this].
+     *
+     * You can use either a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter], or any of the `vararg` overloads for any
+     * [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]. The function can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index (range)).
+     *
+     * This function operates solely on columns at the top-level.
+     *
+     * Aside from calling [cols][org.jetbrains.kotlinx.dataframe.api.ColsColumnsSelectionDsl.cols] directly, you can also use the [`get`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.get] operator in most cases.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColsColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     * `df.`[`remove`][org.jetbrains.kotlinx.dataframe.DataFrame.remove]`  {  `[`cols`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]` { it.`[`hasNulls`][org.jetbrains.kotlinx.dataframe.DataColumn.hasNulls]`() } }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myGroupCol.`[`cols`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.cols]`(columnA, columnB) }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[`colsOf`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[`String`][String]`>()`[`[`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.cols]`1, 3, 5`[`]`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.cols]` }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { Type::columnGroup.`[`cols`][kotlin.reflect.KProperty.cols]`  { "e"  `[`in`][String.contains]` it.`[`name`][org.jetbrains.kotlinx.dataframe.columns.ColumnPath.name]`() } }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { Type::columnGroup`[`[`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.cols]`{ it.`[`any`][org.jetbrains.kotlinx.dataframe.DataColumn.any]` { it == "Alice" } }`[`]`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.cols]` }`
+     *
+     * `// same as `[`allCols`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allCols]`()`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { Type::columnGroup.`[`cols`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.cols]`() }`
+     *
+     *
+     * #### Filter vs. Cols:
+     * If used with a [predicate], `cols {}` functions exactly like [`filter {}`][org.jetbrains.kotlinx.dataframe.api.FilterColumnsSelectionDsl.filter].
+     * This is intentional, however; it is recommended to use `filter {}` on [ColumnSets][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] and
+     * `cols {}` on the rest.
+     *
+     * @param [predicate] A [ColumnFilter function][org.jetbrains.kotlinx.dataframe.ColumnFilter] that takes a [ColumnReference][org.jetbrains.kotlinx.dataframe.columns.ColumnReference] and returns a [Boolean].
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing the columns that match the given [predicate].
+     * @see [ColumnsSelectionDsl.filter]
+     * @see [ColumnsSelectionDsl.colsOfKind]
+     * @see [ColumnsSelectionDsl.valueCols]
+     * @see [ColumnsSelectionDsl.frameCols]
+     * @see [ColumnsSelectionDsl.colGroups]
+     * @see [ColumnsSelectionDsl.allCols] */
+    public fun KProperty<*>.cols(predicate: ColumnFilter<*> = { true }): TransformableColumnSet<*> =
+        columnGroup(this).cols(predicate)
+
+    /** ## Cols
+     * Creates a subset of columns ([ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]) from [this].
+     *
+     * You can use either a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter], or any of the `vararg` overloads for any
+     * [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]. The function can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index (range)).
+     *
+     * This function operates solely on columns at the top-level.
+     *
+     * Aside from calling [cols][org.jetbrains.kotlinx.dataframe.api.ColsColumnsSelectionDsl.cols] directly, you can also use the [`get`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.get] operator in most cases.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColsColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     * `df.`[`remove`][org.jetbrains.kotlinx.dataframe.DataFrame.remove]`  {  `[`cols`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]` { it.`[`hasNulls`][org.jetbrains.kotlinx.dataframe.DataColumn.hasNulls]`() } }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myGroupCol.`[`cols`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.cols]`(columnA, columnB) }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[`colsOf`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[`String`][String]`>()`[`[`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.cols]`1, 3, 5`[`]`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.cols]` }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { Type::columnGroup.`[`cols`][kotlin.reflect.KProperty.cols]`  { "e"  `[`in`][String.contains]` it.`[`name`][org.jetbrains.kotlinx.dataframe.columns.ColumnPath.name]`() } }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { Type::columnGroup`[`[`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.cols]`{ it.`[`any`][org.jetbrains.kotlinx.dataframe.DataColumn.any]` { it == "Alice" } }`[`]`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.cols]` }`
+     *
+     * `// same as `[`allCols`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allCols]`()`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { Type::columnGroup.`[`cols`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.cols]`() }`
+     *
+     *
+     * #### Filter vs. Cols:
+     * If used with a [predicate], `cols {}` functions exactly like [`filter {}`][org.jetbrains.kotlinx.dataframe.api.FilterColumnsSelectionDsl.filter].
+     * This is intentional, however; it is recommended to use `filter {}` on [ColumnSets][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] and
+     * `cols {}` on the rest.
+     *
+     * @param [predicate] A [ColumnFilter function][org.jetbrains.kotlinx.dataframe.ColumnFilter] that takes a [ColumnReference][org.jetbrains.kotlinx.dataframe.columns.ColumnReference] and returns a [Boolean].
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing the columns that match the given [predicate].
+     * @see [ColumnsSelectionDsl.filter]
+     * @see [ColumnsSelectionDsl.colsOfKind]
+     * @see [ColumnsSelectionDsl.valueCols]
+     * @see [ColumnsSelectionDsl.frameCols]
+     * @see [ColumnsSelectionDsl.colGroups]
+     * @see [ColumnsSelectionDsl.allCols] */
+    public operator fun KProperty<*>.get(predicate: ColumnFilter<*> = { true }): TransformableColumnSet<*> =
+        cols(predicate)
+
+    /**
+     * ## Cols
+     * Creates a subset of columns ([ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]) from [this].
+     *
+     * You can use either a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter], or any of the `vararg` overloads for any
+     * [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]. The function can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index (range)).
+     *
+     * This function operates solely on columns at the top-level.
+     *
+     * Aside from calling [cols][org.jetbrains.kotlinx.dataframe.api.ColsColumnsSelectionDsl.cols] directly, you can also use the [`get`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.get] operator in most cases.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColsColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     * `df.`[`remove`][org.jetbrains.kotlinx.dataframe.DataFrame.remove]`  {  `[`cols`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]` { it.`[`hasNulls`][org.jetbrains.kotlinx.dataframe.DataColumn.hasNulls]`() } }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myGroupCol.`[`cols`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.cols]`(columnA, columnB) }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[`colsOf`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[`String`][String]`>()`[`[`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.cols]`1, 3, 5`[`]`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.cols]` }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[`select`][DataFrame.select]` { "pathTo"["myGroupCol"].`[`cols`][ColumnPath.cols]`  { "e"  `[`in`][String.contains]` it.`[`name`][ColumnPath.name]`() } }`
+     *
+     * `df.`[`select`][DataFrame.select]` { "pathTo"["myGroupCol"]`[`[`][ColumnPath.cols]`{ it.`[`any`][ColumnWithPath.any]` { it == "Alice" } }`[`]`][ColumnPath.cols]` }`
+     *
+     * `df.`[`select`][DataFrame.select]` { "pathTo"["myGroupCol"].`[`cols`][ColumnPath.cols]`() } // identity call, same as `[`allCols`][ColumnsSelectionDsl.allCols]
+     *
+     *
+     * #### Filter vs. Cols:
+     * If used with a [predicate], `cols {}` functions exactly like [`filter {}`][org.jetbrains.kotlinx.dataframe.api.FilterColumnsSelectionDsl.filter].
+     * This is intentional, however; it is recommended to use `filter {}` on [ColumnSets][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] and
+     * `cols {}` on the rest.
+     *
+     * @param [predicate] A [ColumnFilter function][org.jetbrains.kotlinx.dataframe.ColumnFilter] that takes a [ColumnReference][org.jetbrains.kotlinx.dataframe.columns.ColumnReference] and returns a [Boolean].
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing the columns that match the given [predicate].
+     * @see [ColumnsSelectionDsl.filter]
+     * @see [ColumnsSelectionDsl.colsOfKind]
+     * @see [ColumnsSelectionDsl.valueCols]
+     * @see [ColumnsSelectionDsl.frameCols]
+     * @see [ColumnsSelectionDsl.colGroups]
+     */
+    private interface ColumnPathPredicateDocs
+
+    /** ## Cols
+     * Creates a subset of columns ([ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]) from [this].
+     *
+     * You can use either a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter], or any of the `vararg` overloads for any
+     * [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]. The function can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index (range)).
+     *
+     * This function operates solely on columns at the top-level.
+     *
+     * Aside from calling [cols][org.jetbrains.kotlinx.dataframe.api.ColsColumnsSelectionDsl.cols] directly, you can also use the [`get`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.get] operator in most cases.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColsColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     * `df.`[`remove`][org.jetbrains.kotlinx.dataframe.DataFrame.remove]`  {  `[`cols`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]` { it.`[`hasNulls`][org.jetbrains.kotlinx.dataframe.DataColumn.hasNulls]`() } }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myGroupCol.`[`cols`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.cols]`(columnA, columnB) }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[`colsOf`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[`String`][String]`>()`[`[`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.cols]`1, 3, 5`[`]`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.cols]` }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "pathTo"["myGroupCol"].`[`cols`][org.jetbrains.kotlinx.dataframe.columns.ColumnPath.cols]`  { "e"  `[`in`][String.contains]` it.`[`name`][org.jetbrains.kotlinx.dataframe.columns.ColumnPath.name]`() } }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "pathTo"["myGroupCol"]`[`[`][org.jetbrains.kotlinx.dataframe.columns.ColumnPath.cols]`{ it.`[`any`][org.jetbrains.kotlinx.dataframe.DataColumn.any]` { it == "Alice" } }`[`]`][org.jetbrains.kotlinx.dataframe.columns.ColumnPath.cols]` }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "pathTo"["myGroupCol"].`[`cols`][org.jetbrains.kotlinx.dataframe.columns.ColumnPath.cols]`() } // identity call, same as `[`allCols`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allCols]
+     *
+     *
+     * #### Filter vs. Cols:
+     * If used with a [predicate], `cols {}` functions exactly like [`filter {}`][org.jetbrains.kotlinx.dataframe.api.FilterColumnsSelectionDsl.filter].
+     * This is intentional, however; it is recommended to use `filter {}` on [ColumnSets][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] and
+     * `cols {}` on the rest.
+     *
+     * @param [predicate] A [ColumnFilter function][org.jetbrains.kotlinx.dataframe.ColumnFilter] that takes a [ColumnReference][org.jetbrains.kotlinx.dataframe.columns.ColumnReference] and returns a [Boolean].
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing the columns that match the given [predicate].
+     * @see [ColumnsSelectionDsl.filter]
+     * @see [ColumnsSelectionDsl.colsOfKind]
+     * @see [ColumnsSelectionDsl.valueCols]
+     * @see [ColumnsSelectionDsl.frameCols]
+     * @see [ColumnsSelectionDsl.colGroups]
+     */
+    public fun ColumnPath.cols(predicate: ColumnFilter<*> = { true }): TransformableColumnSet<*> =
+        columnGroup(this).cols(predicate)
+
+    /** ## Cols
+     * Creates a subset of columns ([ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]) from [this].
+     *
+     * You can use either a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter], or any of the `vararg` overloads for any
+     * [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]. The function can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index (range)).
+     *
+     * This function operates solely on columns at the top-level.
+     *
+     * Aside from calling [cols][org.jetbrains.kotlinx.dataframe.api.ColsColumnsSelectionDsl.cols] directly, you can also use the [`get`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.get] operator in most cases.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColsColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     * `df.`[`remove`][org.jetbrains.kotlinx.dataframe.DataFrame.remove]`  {  `[`cols`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]` { it.`[`hasNulls`][org.jetbrains.kotlinx.dataframe.DataColumn.hasNulls]`() } }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myGroupCol.`[`cols`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.cols]`(columnA, columnB) }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[`colsOf`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[`String`][String]`>()`[`[`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.cols]`1, 3, 5`[`]`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.cols]` }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "pathTo"["myGroupCol"].`[`cols`][org.jetbrains.kotlinx.dataframe.columns.ColumnPath.cols]`  { "e"  `[`in`][String.contains]` it.`[`name`][org.jetbrains.kotlinx.dataframe.columns.ColumnPath.name]`() } }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "pathTo"["myGroupCol"]`[`[`][org.jetbrains.kotlinx.dataframe.columns.ColumnPath.cols]`{ it.`[`any`][org.jetbrains.kotlinx.dataframe.DataColumn.any]` { it == "Alice" } }`[`]`][org.jetbrains.kotlinx.dataframe.columns.ColumnPath.cols]` }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "pathTo"["myGroupCol"].`[`cols`][org.jetbrains.kotlinx.dataframe.columns.ColumnPath.cols]`() } // identity call, same as `[`allCols`][org.jetbrains.kotlinx.dataframe.api.AllColumnsSelectionDsl.allCols]
+     *
+     *
+     * #### Filter vs. Cols:
+     * If used with a [predicate], `cols {}` functions exactly like [`filter {}`][org.jetbrains.kotlinx.dataframe.api.FilterColumnsSelectionDsl.filter].
+     * This is intentional, however; it is recommended to use `filter {}` on [ColumnSets][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] and
+     * `cols {}` on the rest.
+     *
+     * @param [predicate] A [ColumnFilter function][org.jetbrains.kotlinx.dataframe.ColumnFilter] that takes a [ColumnReference][org.jetbrains.kotlinx.dataframe.columns.ColumnReference] and returns a [Boolean].
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing the columns that match the given [predicate].
+     * @see [ColumnsSelectionDsl.filter]
+     * @see [ColumnsSelectionDsl.colsOfKind]
+     * @see [ColumnsSelectionDsl.valueCols]
+     * @see [ColumnsSelectionDsl.frameCols]
+     * @see [ColumnsSelectionDsl.colGroups]
+     */
+    public operator fun ColumnPath.get(predicate: ColumnFilter<*> = { true }): TransformableColumnSet<*> =
+        cols(predicate)
+
+    // endregion
+
+    // region references
+
+    /**
+     * ## Cols
+     * Creates a subset of columns ([ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]) from [this].
+     *
+     * You can use either a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter], or any of the `vararg` overloads for any
+     * [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]. The function can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index (range)).
+     *
+     * This function operates solely on columns at the top-level.
+     *
+     * Aside from calling [cols][org.jetbrains.kotlinx.dataframe.api.ColsColumnsSelectionDsl.cols] directly, you can also use the [`get`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.get] operator in most cases.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColsColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     * `df.`[`remove`][org.jetbrains.kotlinx.dataframe.DataFrame.remove]`  {  `[`cols`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]` { it.`[`hasNulls`][org.jetbrains.kotlinx.dataframe.DataColumn.hasNulls]`() } }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myGroupCol.`[`cols`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.cols]`(columnA, columnB) }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[`colsOf`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[`String`][String]`>()`[`[`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.cols]`1, 3, 5`[`]`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.cols]` }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[`select`][DataFrame.select]`  {  `[`cols`][ColumnsSelectionDsl.cols]`(colGroup.columnA, columnB) }`
+     *
+     * `df.`[`select`][DataFrame.select]` { this`[`[`][ColumnsSelectionDsl.cols]`colGroup.columnA, columnB`[`]`][ColumnsSelectionDsl.cols]` }`
+     *
+     *
+     * @param [firstCol] A [ColumnReference] that points to a relative column.
+     * @param [otherCols] Optional additional [ColumnReference]s that point to relative columns.
+     * @throws [IllegalArgumentException] if any of the given [ColumnReference][org.jetbrains.kotlinx.dataframe.columns.ColumnReference]s point to a column that doesn't
+     *   exist.
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing the columns that [firstCol] and [otherCols] point to.
+     */
+    private interface ColumnsSelectionDslColsVarargColumnReferenceDocs
+
+    /** ## Cols
+     * Creates a subset of columns ([ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]) from [this].
+     *
+     * You can use either a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter], or any of the `vararg` overloads for any
+     * [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]. The function can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index (range)).
+     *
+     * This function operates solely on columns at the top-level.
+     *
+     * Aside from calling [cols][org.jetbrains.kotlinx.dataframe.api.ColsColumnsSelectionDsl.cols] directly, you can also use the [`get`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.get] operator in most cases.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColsColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     * `df.`[`remove`][org.jetbrains.kotlinx.dataframe.DataFrame.remove]`  {  `[`cols`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]` { it.`[`hasNulls`][org.jetbrains.kotlinx.dataframe.DataColumn.hasNulls]`() } }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myGroupCol.`[`cols`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.cols]`(columnA, columnB) }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[`colsOf`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[`String`][String]`>()`[`[`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.cols]`1, 3, 5`[`]`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.cols]` }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[`cols`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`(colGroup.columnA, columnB) }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { this`[`[`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`colGroup.columnA, columnB`[`]`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]` }`
+     *
+     *
+     * @param [firstCol] A [ColumnReference][org.jetbrains.kotlinx.dataframe.columns.ColumnReference] that points to a relative column.
+     * @param [otherCols] Optional additional [ColumnReference][org.jetbrains.kotlinx.dataframe.columns.ColumnReference]s that point to relative columns.
+     * @throws [IllegalArgumentException] if any of the given [ColumnReference][org.jetbrains.kotlinx.dataframe.columns.ColumnReference]s point to a column that doesn't
+     *   exist.
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing the columns that [firstCol] and [otherCols] point to.
+     */
+    public fun <C> ColumnsSelectionDsl<*>.cols(
+        firstCol: ColumnReference<C>,
+        vararg otherCols: ColumnReference<C>,
+    ): ColumnSet<C> = asSingleColumn().cols(firstCol, *otherCols)
+
+    /** ## Cols
+     * Creates a subset of columns ([ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]) from [this].
+     *
+     * You can use either a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter], or any of the `vararg` overloads for any
+     * [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]. The function can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index (range)).
+     *
+     * This function operates solely on columns at the top-level.
+     *
+     * Aside from calling [cols][org.jetbrains.kotlinx.dataframe.api.ColsColumnsSelectionDsl.cols] directly, you can also use the [`get`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.get] operator in most cases.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColsColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     * `df.`[`remove`][org.jetbrains.kotlinx.dataframe.DataFrame.remove]`  {  `[`cols`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]` { it.`[`hasNulls`][org.jetbrains.kotlinx.dataframe.DataColumn.hasNulls]`() } }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myGroupCol.`[`cols`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.cols]`(columnA, columnB) }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[`colsOf`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[`String`][String]`>()`[`[`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.cols]`1, 3, 5`[`]`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.cols]` }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[`cols`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`(colGroup.columnA, columnB) }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { this`[`[`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`colGroup.columnA, columnB`[`]`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]` }`
+     *
+     *
+     * @param [firstCol] A [ColumnReference][org.jetbrains.kotlinx.dataframe.columns.ColumnReference] that points to a relative column.
+     * @param [otherCols] Optional additional [ColumnReference][org.jetbrains.kotlinx.dataframe.columns.ColumnReference]s that point to relative columns.
+     * @throws [IllegalArgumentException] if any of the given [ColumnReference][org.jetbrains.kotlinx.dataframe.columns.ColumnReference]s point to a column that doesn't
+     *   exist.
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing the columns that [firstCol] and [otherCols] point to.
+     */
+    public operator fun <C> ColumnsSelectionDsl<*>.get(
+        firstCol: ColumnReference<C>,
+        vararg otherCols: ColumnReference<C>,
+    ): ColumnSet<C> = cols(firstCol, *otherCols)
+
+    /**
+     * ## Cols
+     * Creates a subset of columns ([ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]) from [this].
+     *
+     * You can use either a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter], or any of the `vararg` overloads for any
+     * [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]. The function can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index (range)).
+     *
+     * This function operates solely on columns at the top-level.
+     *
+     * Aside from calling [cols][org.jetbrains.kotlinx.dataframe.api.ColsColumnsSelectionDsl.cols] directly, you can also use the [`get`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.get] operator in most cases.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColsColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     * `df.`[`remove`][org.jetbrains.kotlinx.dataframe.DataFrame.remove]`  {  `[`cols`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]` { it.`[`hasNulls`][org.jetbrains.kotlinx.dataframe.DataColumn.hasNulls]`() } }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myGroupCol.`[`cols`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.cols]`(columnA, columnB) }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[`colsOf`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[`String`][String]`>()`[`[`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.cols]`1, 3, 5`[`]`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.cols]` }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[`select`][DataFrame.select]` { myColumnGroup.`[`cols`][SingleColumn.cols]`(columnA, columnB) }`
+     *
+     * `df.`[`select`][DataFrame.select]` { myColumnGroup`[`[`][SingleColumn.cols]`columnA, columnB`[`]`][SingleColumn.cols]` }`
+     *
+     *
+     * @param [firstCol] A [ColumnReference] that points to a relative column.
+     * @param [otherCols] Optional additional [ColumnReference]s that point to relative columns.
+     * @throws [IllegalArgumentException] if any of the given [ColumnReference][org.jetbrains.kotlinx.dataframe.columns.ColumnReference]s point to a column that doesn't
+     *   exist.
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing the columns that [firstCol] and [otherCols] point to.
+     */
+    private interface SingleColumnColsVarargColumnReferenceDocs
+
+    /** ## Cols
+     * Creates a subset of columns ([ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]) from [this].
+     *
+     * You can use either a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter], or any of the `vararg` overloads for any
+     * [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]. The function can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index (range)).
+     *
+     * This function operates solely on columns at the top-level.
+     *
+     * Aside from calling [cols][org.jetbrains.kotlinx.dataframe.api.ColsColumnsSelectionDsl.cols] directly, you can also use the [`get`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.get] operator in most cases.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColsColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     * `df.`[`remove`][org.jetbrains.kotlinx.dataframe.DataFrame.remove]`  {  `[`cols`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]` { it.`[`hasNulls`][org.jetbrains.kotlinx.dataframe.DataColumn.hasNulls]`() } }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myGroupCol.`[`cols`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.cols]`(columnA, columnB) }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[`colsOf`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[`String`][String]`>()`[`[`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.cols]`1, 3, 5`[`]`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.cols]` }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[`cols`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.cols]`(columnA, columnB) }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup`[`[`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.cols]`columnA, columnB`[`]`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.cols]` }`
+     *
+     *
+     * @param [firstCol] A [ColumnReference][org.jetbrains.kotlinx.dataframe.columns.ColumnReference] that points to a relative column.
+     * @param [otherCols] Optional additional [ColumnReference][org.jetbrains.kotlinx.dataframe.columns.ColumnReference]s that point to relative columns.
+     * @throws [IllegalArgumentException] if any of the given [ColumnReference][org.jetbrains.kotlinx.dataframe.columns.ColumnReference]s point to a column that doesn't
+     *   exist.
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing the columns that [firstCol] and [otherCols] point to.
+     */
+    public fun <C> SingleColumn<DataRow<*>>.cols(
+        firstCol: ColumnReference<C>,
+        vararg otherCols: ColumnReference<C>,
+    ): ColumnSet<C> = colsInternal(listOf(firstCol, *otherCols)).cast()
+
+    /**
+     * ## Cols
+     * Creates a subset of columns ([ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]) from [this].
+     *
+     * You can use either a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter], or any of the `vararg` overloads for any
+     * [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]. The function can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index (range)).
+     *
+     * This function operates solely on columns at the top-level.
+     *
+     * Aside from calling [cols][org.jetbrains.kotlinx.dataframe.api.ColsColumnsSelectionDsl.cols] directly, you can also use the [`get`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.get] operator in most cases.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColsColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     * `df.`[`remove`][org.jetbrains.kotlinx.dataframe.DataFrame.remove]`  {  `[`cols`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]` { it.`[`hasNulls`][org.jetbrains.kotlinx.dataframe.DataColumn.hasNulls]`() } }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myGroupCol.`[`cols`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.cols]`(columnA, columnB) }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[`colsOf`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[`String`][String]`>()`[`[`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.cols]`1, 3, 5`[`]`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.cols]` }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[`cols`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.cols]`(columnA, columnB) }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup`[`[`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.cols]`columnA, columnB`[`]`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.cols]` }`
+     *
+     *
+     * @param [firstCol] A [ColumnReference][org.jetbrains.kotlinx.dataframe.columns.ColumnReference] that points to a relative column.
+     * @param [otherCols] Optional additional [ColumnReference][org.jetbrains.kotlinx.dataframe.columns.ColumnReference]s that point to relative columns.
+     * @throws [IllegalArgumentException] if any of the given [ColumnReference][org.jetbrains.kotlinx.dataframe.columns.ColumnReference]s point to a column that doesn't
+     *   exist.
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing the columns that [firstCol] and [otherCols] point to.
+     */
+    public operator fun <C> SingleColumn<DataRow<*>>.get(
+        firstCol: ColumnReference<C>,
+        vararg otherCols: ColumnReference<C>,
+    ): ColumnSet<C> = cols(firstCol, *otherCols)
+
+    /**
+     * ## Cols
+     * Creates a subset of columns ([ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]) from [this].
+     *
+     * You can use either a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter], or any of the `vararg` overloads for any
+     * [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]. The function can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index (range)).
+     *
+     * This function operates solely on columns at the top-level.
+     *
+     * Aside from calling [cols][org.jetbrains.kotlinx.dataframe.api.ColsColumnsSelectionDsl.cols] directly, you can also use the [`get`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.get] operator in most cases.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColsColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     * `df.`[`remove`][org.jetbrains.kotlinx.dataframe.DataFrame.remove]`  {  `[`cols`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]` { it.`[`hasNulls`][org.jetbrains.kotlinx.dataframe.DataColumn.hasNulls]`() } }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myGroupCol.`[`cols`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.cols]`(columnA, columnB) }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[`colsOf`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[`String`][String]`>()`[`[`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.cols]`1, 3, 5`[`]`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.cols]` }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[`select`][DataFrame.select]` { "myColumnGroup".`[`cols`][String.cols]`(columnA, columnB) }`
+     *
+     * `df.`[`select`][DataFrame.select]` { "myColumnGroup"`[`[`][String.cols]`columnA, columnB`[`]`][String.cols]` }`
+     *
+     *
+     * @param [firstCol] A [ColumnReference] that points to a relative column.
+     * @param [otherCols] Optional additional [ColumnReference]s that point to relative columns.
+     * @throws [IllegalArgumentException] if any of the given [ColumnReference][org.jetbrains.kotlinx.dataframe.columns.ColumnReference]s point to a column that doesn't
+     *   exist.
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing the columns that [firstCol] and [otherCols] point to.
+     */
+    private interface StringColsVarargColumnReferenceDocs
+
+    /** ## Cols
+     * Creates a subset of columns ([ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]) from [this].
+     *
+     * You can use either a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter], or any of the `vararg` overloads for any
+     * [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]. The function can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index (range)).
+     *
+     * This function operates solely on columns at the top-level.
+     *
+     * Aside from calling [cols][org.jetbrains.kotlinx.dataframe.api.ColsColumnsSelectionDsl.cols] directly, you can also use the [`get`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.get] operator in most cases.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColsColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     * `df.`[`remove`][org.jetbrains.kotlinx.dataframe.DataFrame.remove]`  {  `[`cols`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]` { it.`[`hasNulls`][org.jetbrains.kotlinx.dataframe.DataColumn.hasNulls]`() } }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myGroupCol.`[`cols`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.cols]`(columnA, columnB) }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[`colsOf`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[`String`][String]`>()`[`[`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.cols]`1, 3, 5`[`]`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.cols]` }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "myColumnGroup".`[`cols`][kotlin.String.cols]`(columnA, columnB) }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "myColumnGroup"`[`[`][kotlin.String.cols]`columnA, columnB`[`]`][kotlin.String.cols]` }`
+     *
+     *
+     * @param [firstCol] A [ColumnReference][org.jetbrains.kotlinx.dataframe.columns.ColumnReference] that points to a relative column.
+     * @param [otherCols] Optional additional [ColumnReference][org.jetbrains.kotlinx.dataframe.columns.ColumnReference]s that point to relative columns.
+     * @throws [IllegalArgumentException] if any of the given [ColumnReference][org.jetbrains.kotlinx.dataframe.columns.ColumnReference]s point to a column that doesn't
+     *   exist.
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing the columns that [firstCol] and [otherCols] point to.
+     */
+    public fun <C> String.cols(firstCol: ColumnReference<C>, vararg otherCols: ColumnReference<C>): ColumnSet<C> =
+        columnGroup(this).cols(firstCol, *otherCols)
+
+    /** ## Cols
+     * Creates a subset of columns ([ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]) from [this].
+     *
+     * You can use either a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter], or any of the `vararg` overloads for any
+     * [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]. The function can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index (range)).
+     *
+     * This function operates solely on columns at the top-level.
+     *
+     * Aside from calling [cols][org.jetbrains.kotlinx.dataframe.api.ColsColumnsSelectionDsl.cols] directly, you can also use the [`get`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.get] operator in most cases.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColsColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     * `df.`[`remove`][org.jetbrains.kotlinx.dataframe.DataFrame.remove]`  {  `[`cols`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]` { it.`[`hasNulls`][org.jetbrains.kotlinx.dataframe.DataColumn.hasNulls]`() } }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myGroupCol.`[`cols`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.cols]`(columnA, columnB) }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[`colsOf`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[`String`][String]`>()`[`[`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.cols]`1, 3, 5`[`]`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.cols]` }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "myColumnGroup".`[`cols`][kotlin.String.cols]`(columnA, columnB) }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "myColumnGroup"`[`[`][kotlin.String.cols]`columnA, columnB`[`]`][kotlin.String.cols]` }`
+     *
+     *
+     * @param [firstCol] A [ColumnReference][org.jetbrains.kotlinx.dataframe.columns.ColumnReference] that points to a relative column.
+     * @param [otherCols] Optional additional [ColumnReference][org.jetbrains.kotlinx.dataframe.columns.ColumnReference]s that point to relative columns.
+     * @throws [IllegalArgumentException] if any of the given [ColumnReference][org.jetbrains.kotlinx.dataframe.columns.ColumnReference]s point to a column that doesn't
+     *   exist.
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing the columns that [firstCol] and [otherCols] point to.
+     */
+    public operator fun <C> String.get(
+        firstCol: ColumnReference<C>,
+        vararg otherCols: ColumnReference<C>,
+    ): ColumnSet<C> = cols(firstCol, *otherCols)
+
+    /**
+     * ## Cols
+     * Creates a subset of columns ([ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]) from [this].
+     *
+     * You can use either a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter], or any of the `vararg` overloads for any
+     * [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]. The function can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index (range)).
+     *
+     * This function operates solely on columns at the top-level.
+     *
+     * Aside from calling [cols][org.jetbrains.kotlinx.dataframe.api.ColsColumnsSelectionDsl.cols] directly, you can also use the [`get`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.get] operator in most cases.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColsColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     * `df.`[`remove`][org.jetbrains.kotlinx.dataframe.DataFrame.remove]`  {  `[`cols`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]` { it.`[`hasNulls`][org.jetbrains.kotlinx.dataframe.DataColumn.hasNulls]`() } }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myGroupCol.`[`cols`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.cols]`(columnA, columnB) }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[`colsOf`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[`String`][String]`>()`[`[`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.cols]`1, 3, 5`[`]`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.cols]` }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[`select`][DataFrame.select]` { Type::myColumnGroup.`[`cols`][SingleColumn.cols]`(columnA, columnB) }`
+     *
+     * `df.`[`select`][DataFrame.select]` { DataSchemaType::myColumnGroup`[`[`][KProperty.cols]`"pathTo"["colA"], "pathTo"["colB"]`[`]`][KProperty.cols]` }`
+     *
+     *
+     * @param [firstCol] A [ColumnReference] that points to a relative column.
+     * @param [otherCols] Optional additional [ColumnReference]s that point to relative columns.
+     * @throws [IllegalArgumentException] if any of the given [ColumnReference][org.jetbrains.kotlinx.dataframe.columns.ColumnReference]s point to a column that doesn't
+     *   exist.
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing the columns that [firstCol] and [otherCols] point to.
+     */
+    private interface KPropertyColsVarargColumnReferenceDocs
+
+    /** ## Cols
+     * Creates a subset of columns ([ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]) from [this].
+     *
+     * You can use either a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter], or any of the `vararg` overloads for any
+     * [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]. The function can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index (range)).
+     *
+     * This function operates solely on columns at the top-level.
+     *
+     * Aside from calling [cols][org.jetbrains.kotlinx.dataframe.api.ColsColumnsSelectionDsl.cols] directly, you can also use the [`get`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.get] operator in most cases.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColsColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     * `df.`[`remove`][org.jetbrains.kotlinx.dataframe.DataFrame.remove]`  {  `[`cols`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]` { it.`[`hasNulls`][org.jetbrains.kotlinx.dataframe.DataColumn.hasNulls]`() } }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myGroupCol.`[`cols`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.cols]`(columnA, columnB) }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[`colsOf`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[`String`][String]`>()`[`[`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.cols]`1, 3, 5`[`]`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.cols]` }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { Type::myColumnGroup.`[`cols`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.cols]`(columnA, columnB) }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { DataSchemaType::myColumnGroup`[`[`][kotlin.reflect.KProperty.cols]`"pathTo"["colA"], "pathTo"["colB"]`[`]`][kotlin.reflect.KProperty.cols]` }`
+     *
+     *
+     * @param [firstCol] A [ColumnReference][org.jetbrains.kotlinx.dataframe.columns.ColumnReference] that points to a relative column.
+     * @param [otherCols] Optional additional [ColumnReference][org.jetbrains.kotlinx.dataframe.columns.ColumnReference]s that point to relative columns.
+     * @throws [IllegalArgumentException] if any of the given [ColumnReference][org.jetbrains.kotlinx.dataframe.columns.ColumnReference]s point to a column that doesn't
+     *   exist.
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing the columns that [firstCol] and [otherCols] point to.
+     */
+    public fun <C> KProperty<*>.cols(
+        firstCol: ColumnReference<C>,
+        vararg otherCols: ColumnReference<C>,
+    ): ColumnSet<C> = columnGroup(this).cols(firstCol, *otherCols)
+
+    /** ## Cols
+     * Creates a subset of columns ([ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]) from [this].
+     *
+     * You can use either a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter], or any of the `vararg` overloads for any
+     * [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]. The function can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index (range)).
+     *
+     * This function operates solely on columns at the top-level.
+     *
+     * Aside from calling [cols][org.jetbrains.kotlinx.dataframe.api.ColsColumnsSelectionDsl.cols] directly, you can also use the [`get`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.get] operator in most cases.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColsColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     * `df.`[`remove`][org.jetbrains.kotlinx.dataframe.DataFrame.remove]`  {  `[`cols`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]` { it.`[`hasNulls`][org.jetbrains.kotlinx.dataframe.DataColumn.hasNulls]`() } }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myGroupCol.`[`cols`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.cols]`(columnA, columnB) }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[`colsOf`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[`String`][String]`>()`[`[`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.cols]`1, 3, 5`[`]`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.cols]` }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { Type::myColumnGroup.`[`cols`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.cols]`(columnA, columnB) }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { DataSchemaType::myColumnGroup`[`[`][kotlin.reflect.KProperty.cols]`"pathTo"["colA"], "pathTo"["colB"]`[`]`][kotlin.reflect.KProperty.cols]` }`
+     *
+     *
+     * @param [firstCol] A [ColumnReference][org.jetbrains.kotlinx.dataframe.columns.ColumnReference] that points to a relative column.
+     * @param [otherCols] Optional additional [ColumnReference][org.jetbrains.kotlinx.dataframe.columns.ColumnReference]s that point to relative columns.
+     * @throws [IllegalArgumentException] if any of the given [ColumnReference][org.jetbrains.kotlinx.dataframe.columns.ColumnReference]s point to a column that doesn't
+     *   exist.
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing the columns that [firstCol] and [otherCols] point to.
+     */
+    public operator fun <C> KProperty<*>.get(
+        firstCol: ColumnReference<C>,
+        vararg otherCols: ColumnReference<C>,
+    ): ColumnSet<C> = cols(firstCol, *otherCols)
+
+    /**
+     * ## Cols
+     * Creates a subset of columns ([ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]) from [this].
+     *
+     * You can use either a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter], or any of the `vararg` overloads for any
+     * [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]. The function can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index (range)).
+     *
+     * This function operates solely on columns at the top-level.
+     *
+     * Aside from calling [cols][org.jetbrains.kotlinx.dataframe.api.ColsColumnsSelectionDsl.cols] directly, you can also use the [`get`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.get] operator in most cases.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColsColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     * `df.`[`remove`][org.jetbrains.kotlinx.dataframe.DataFrame.remove]`  {  `[`cols`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]` { it.`[`hasNulls`][org.jetbrains.kotlinx.dataframe.DataColumn.hasNulls]`() } }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myGroupCol.`[`cols`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.cols]`(columnA, columnB) }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[`colsOf`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[`String`][String]`>()`[`[`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.cols]`1, 3, 5`[`]`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.cols]` }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[`select`][DataFrame.select]` { "pathTo"["columnGroup"].`[`cols`][ColumnPath.cols]`(columnA, columnB) }`
+     *
+     * `df.`[`select`][DataFrame.select]` { "pathTo"["columnGroup"].`[`cols`][ColumnPath.cols]`("pathTo"["colA"], "pathTo"["colB"]) }`
+     *
+     * `df.`[`select`][DataFrame.select]` { "pathTo"["columnGroup"]`[`[`][ColumnPath.cols]`columnA, columnB`[`]`][ColumnPath.cols]` }`
+     *
+     *
+     * @param [firstCol] A [ColumnReference] that points to a relative column.
+     * @param [otherCols] Optional additional [ColumnReference]s that point to relative columns.
+     * @throws [IllegalArgumentException] if any of the given [ColumnReference][org.jetbrains.kotlinx.dataframe.columns.ColumnReference]s point to a column that doesn't
+     *   exist.
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing the columns that [firstCol] and [otherCols] point to.
+     */
+    private interface ColumnPathColsVarargColumnReferenceDocs
+
+    /** ## Cols
+     * Creates a subset of columns ([ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]) from [this].
+     *
+     * You can use either a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter], or any of the `vararg` overloads for any
+     * [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]. The function can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index (range)).
+     *
+     * This function operates solely on columns at the top-level.
+     *
+     * Aside from calling [cols][org.jetbrains.kotlinx.dataframe.api.ColsColumnsSelectionDsl.cols] directly, you can also use the [`get`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.get] operator in most cases.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColsColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     * `df.`[`remove`][org.jetbrains.kotlinx.dataframe.DataFrame.remove]`  {  `[`cols`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]` { it.`[`hasNulls`][org.jetbrains.kotlinx.dataframe.DataColumn.hasNulls]`() } }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myGroupCol.`[`cols`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.cols]`(columnA, columnB) }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[`colsOf`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[`String`][String]`>()`[`[`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.cols]`1, 3, 5`[`]`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.cols]` }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "pathTo"["columnGroup"].`[`cols`][org.jetbrains.kotlinx.dataframe.columns.ColumnPath.cols]`(columnA, columnB) }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "pathTo"["columnGroup"].`[`cols`][org.jetbrains.kotlinx.dataframe.columns.ColumnPath.cols]`("pathTo"["colA"], "pathTo"["colB"]) }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "pathTo"["columnGroup"]`[`[`][org.jetbrains.kotlinx.dataframe.columns.ColumnPath.cols]`columnA, columnB`[`]`][org.jetbrains.kotlinx.dataframe.columns.ColumnPath.cols]` }`
+     *
+     *
+     * @param [firstCol] A [ColumnReference][org.jetbrains.kotlinx.dataframe.columns.ColumnReference] that points to a relative column.
+     * @param [otherCols] Optional additional [ColumnReference][org.jetbrains.kotlinx.dataframe.columns.ColumnReference]s that point to relative columns.
+     * @throws [IllegalArgumentException] if any of the given [ColumnReference][org.jetbrains.kotlinx.dataframe.columns.ColumnReference]s point to a column that doesn't
+     *   exist.
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing the columns that [firstCol] and [otherCols] point to.
+     */
+    public fun <C> ColumnPath.cols(firstCol: ColumnReference<C>, vararg otherCols: ColumnReference<C>): ColumnSet<C> =
+        columnGroup(this).cols(firstCol, *otherCols)
+
+    /** ## Cols
+     * Creates a subset of columns ([ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]) from [this].
+     *
+     * You can use either a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter], or any of the `vararg` overloads for any
+     * [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]. The function can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index (range)).
+     *
+     * This function operates solely on columns at the top-level.
+     *
+     * Aside from calling [cols][org.jetbrains.kotlinx.dataframe.api.ColsColumnsSelectionDsl.cols] directly, you can also use the [`get`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.get] operator in most cases.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColsColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     * `df.`[`remove`][org.jetbrains.kotlinx.dataframe.DataFrame.remove]`  {  `[`cols`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]` { it.`[`hasNulls`][org.jetbrains.kotlinx.dataframe.DataColumn.hasNulls]`() } }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myGroupCol.`[`cols`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.cols]`(columnA, columnB) }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[`colsOf`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[`String`][String]`>()`[`[`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.cols]`1, 3, 5`[`]`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.cols]` }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "pathTo"["columnGroup"].`[`cols`][org.jetbrains.kotlinx.dataframe.columns.ColumnPath.cols]`(columnA, columnB) }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "pathTo"["columnGroup"].`[`cols`][org.jetbrains.kotlinx.dataframe.columns.ColumnPath.cols]`("pathTo"["colA"], "pathTo"["colB"]) }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "pathTo"["columnGroup"]`[`[`][org.jetbrains.kotlinx.dataframe.columns.ColumnPath.cols]`columnA, columnB`[`]`][org.jetbrains.kotlinx.dataframe.columns.ColumnPath.cols]` }`
+     *
+     *
+     * @param [firstCol] A [ColumnReference][org.jetbrains.kotlinx.dataframe.columns.ColumnReference] that points to a relative column.
+     * @param [otherCols] Optional additional [ColumnReference][org.jetbrains.kotlinx.dataframe.columns.ColumnReference]s that point to relative columns.
+     * @throws [IllegalArgumentException] if any of the given [ColumnReference][org.jetbrains.kotlinx.dataframe.columns.ColumnReference]s point to a column that doesn't
+     *   exist.
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing the columns that [firstCol] and [otherCols] point to.
+     */
+    public operator fun <C> ColumnPath.get(
+        firstCol: ColumnReference<C>,
+        vararg otherCols: ColumnReference<C>,
+    ): ColumnSet<C> = cols(firstCol, *otherCols)
+
+    // endregion
+
+    // region names
+
+    /**
+     * ## Cols
+     * Creates a subset of columns ([ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]) from [this].
+     *
+     * You can use either a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter], or any of the `vararg` overloads for any
+     * [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]. The function can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index (range)).
+     *
+     * This function operates solely on columns at the top-level.
+     *
+     * Aside from calling [cols][org.jetbrains.kotlinx.dataframe.api.ColsColumnsSelectionDsl.cols] directly, you can also use the [`get`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.get] operator in most cases.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColsColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     * `df.`[`remove`][org.jetbrains.kotlinx.dataframe.DataFrame.remove]`  {  `[`cols`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]` { it.`[`hasNulls`][org.jetbrains.kotlinx.dataframe.DataColumn.hasNulls]`() } }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myGroupCol.`[`cols`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.cols]`(columnA, columnB) }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[`colsOf`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[`String`][String]`>()`[`[`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.cols]`1, 3, 5`[`]`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.cols]` }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[`select`][DataFrame.select]`  {  `[`cols`][ColumnsSelectionDsl.cols]`("columnA", "columnB") }`
+     *
+     * `df.`[`select`][DataFrame.select]`  {  `[`cols`][ColumnsSelectionDsl.cols]`<`[`String`][String]`>("columnA", "columnB") }`
+     *
+     * `df.`[`select`][DataFrame.select]` { this`[`[`][ColumnsSelectionDsl.cols]`"columnA", "columnB"`[`]`][ColumnsSelectionDsl.cols]` }`
+     *
+     *
+     * @param [firstCol] A [String] that points to a relative column.
+     * @param [otherCols] Optional additional [String]s that point to relative columns.
+     * @throws [IllegalArgumentException] if any of the given [ColumnReference][org.jetbrains.kotlinx.dataframe.columns.ColumnReference]s point to a column that doesn't
+     *   exist.
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing the columns that [firstCol] and [otherCols] point to.
+     */
+    private interface ColumnsSelectionDslVarargStringDocs
+
+    /** ## Cols
+     * Creates a subset of columns ([ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]) from [this].
+     *
+     * You can use either a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter], or any of the `vararg` overloads for any
+     * [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]. The function can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index (range)).
+     *
+     * This function operates solely on columns at the top-level.
+     *
+     * Aside from calling [cols][org.jetbrains.kotlinx.dataframe.api.ColsColumnsSelectionDsl.cols] directly, you can also use the [`get`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.get] operator in most cases.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColsColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     * `df.`[`remove`][org.jetbrains.kotlinx.dataframe.DataFrame.remove]`  {  `[`cols`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]` { it.`[`hasNulls`][org.jetbrains.kotlinx.dataframe.DataColumn.hasNulls]`() } }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myGroupCol.`[`cols`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.cols]`(columnA, columnB) }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[`colsOf`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[`String`][String]`>()`[`[`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.cols]`1, 3, 5`[`]`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.cols]` }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[`cols`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`("columnA", "columnB") }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[`cols`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`<`[`String`][String]`>("columnA", "columnB") }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { this`[`[`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`"columnA", "columnB"`[`]`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]` }`
+     *
+     *
+     * @param [firstCol] A [String] that points to a relative column.
+     * @param [otherCols] Optional additional [String]s that point to relative columns.
+     * @throws [IllegalArgumentException] if any of the given [ColumnReference][org.jetbrains.kotlinx.dataframe.columns.ColumnReference]s point to a column that doesn't
+     *   exist.
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing the columns that [firstCol] and [otherCols] point to.
+     */
+    @Suppress("INAPPLICABLE_JVM_NAME")
+    @JvmName("colsUnTyped")
+    public fun ColumnsSelectionDsl<*>.cols(firstCol: String, vararg otherCols: String): ColumnSet<*> =
+        cols<Any?>(firstCol, *otherCols)
+
+    /** ## Cols
+     * Creates a subset of columns ([ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]) from [this].
+     *
+     * You can use either a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter], or any of the `vararg` overloads for any
+     * [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]. The function can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index (range)).
+     *
+     * This function operates solely on columns at the top-level.
+     *
+     * Aside from calling [cols][org.jetbrains.kotlinx.dataframe.api.ColsColumnsSelectionDsl.cols] directly, you can also use the [`get`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.get] operator in most cases.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColsColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     * `df.`[`remove`][org.jetbrains.kotlinx.dataframe.DataFrame.remove]`  {  `[`cols`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]` { it.`[`hasNulls`][org.jetbrains.kotlinx.dataframe.DataColumn.hasNulls]`() } }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myGroupCol.`[`cols`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.cols]`(columnA, columnB) }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[`colsOf`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[`String`][String]`>()`[`[`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.cols]`1, 3, 5`[`]`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.cols]` }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[`cols`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`("columnA", "columnB") }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[`cols`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`<`[`String`][String]`>("columnA", "columnB") }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { this`[`[`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`"columnA", "columnB"`[`]`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]` }`
+     *
+     *
+     * @param [firstCol] A [String] that points to a relative column.
+     * @param [otherCols] Optional additional [String]s that point to relative columns.
+     * @throws [IllegalArgumentException] if any of the given [ColumnReference][org.jetbrains.kotlinx.dataframe.columns.ColumnReference]s point to a column that doesn't
+     *   exist.
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing the columns that [firstCol] and [otherCols] point to.
+     */
+    public fun <T> ColumnsSelectionDsl<*>.cols(firstCol: String, vararg otherCols: String): ColumnSet<T> =
+        this.asSingleColumn().cols(firstCol, *otherCols).cast()
+
+    /** ## Cols
+     * Creates a subset of columns ([ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]) from [this].
+     *
+     * You can use either a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter], or any of the `vararg` overloads for any
+     * [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]. The function can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index (range)).
+     *
+     * This function operates solely on columns at the top-level.
+     *
+     * Aside from calling [cols][org.jetbrains.kotlinx.dataframe.api.ColsColumnsSelectionDsl.cols] directly, you can also use the [`get`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.get] operator in most cases.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColsColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     * `df.`[`remove`][org.jetbrains.kotlinx.dataframe.DataFrame.remove]`  {  `[`cols`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]` { it.`[`hasNulls`][org.jetbrains.kotlinx.dataframe.DataColumn.hasNulls]`() } }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myGroupCol.`[`cols`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.cols]`(columnA, columnB) }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[`colsOf`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[`String`][String]`>()`[`[`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.cols]`1, 3, 5`[`]`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.cols]` }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[`cols`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`("columnA", "columnB") }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[`cols`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`<`[`String`][String]`>("columnA", "columnB") }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { this`[`[`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`"columnA", "columnB"`[`]`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]` }`
+     *
+     *
+     * @param [firstCol] A [String] that points to a relative column.
+     * @param [otherCols] Optional additional [String]s that point to relative columns.
+     * @throws [IllegalArgumentException] if any of the given [ColumnReference][org.jetbrains.kotlinx.dataframe.columns.ColumnReference]s point to a column that doesn't
+     *   exist.
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing the columns that [firstCol] and [otherCols] point to.
+     */
+    public operator fun ColumnsSelectionDsl<*>.get(firstCol: String, vararg otherCols: String): ColumnSet<*> =
+        cols<Any?>(firstCol, *otherCols)
+
+    /**
+     * ## Cols
+     * Creates a subset of columns ([ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]) from [this].
+     *
+     * You can use either a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter], or any of the `vararg` overloads for any
+     * [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]. The function can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index (range)).
+     *
+     * This function operates solely on columns at the top-level.
+     *
+     * Aside from calling [cols][org.jetbrains.kotlinx.dataframe.api.ColsColumnsSelectionDsl.cols] directly, you can also use the [`get`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.get] operator in most cases.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColsColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     * `df.`[`remove`][org.jetbrains.kotlinx.dataframe.DataFrame.remove]`  {  `[`cols`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]` { it.`[`hasNulls`][org.jetbrains.kotlinx.dataframe.DataColumn.hasNulls]`() } }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myGroupCol.`[`cols`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.cols]`(columnA, columnB) }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[`colsOf`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[`String`][String]`>()`[`[`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.cols]`1, 3, 5`[`]`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.cols]` }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[`select`][DataFrame.select]` { myColumnGroup.`[`cols`][SingleColumn.cols]`("columnA", "columnB") }`
+     *
+     * `df.`[`select`][DataFrame.select]` { myColumnGroup`[`[`][SingleColumn.cols]`"columnA", "columnB"`[`]`][SingleColumn.cols]` }`
+     *
+     *
+     * @param [firstCol] A [String] that points to a relative column.
+     * @param [otherCols] Optional additional [String]s that point to relative columns.
+     * @throws [IllegalArgumentException] if any of the given [ColumnReference][org.jetbrains.kotlinx.dataframe.columns.ColumnReference]s point to a column that doesn't
+     *   exist.
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing the columns that [firstCol] and [otherCols] point to.
+     */
+    private interface SingleColumnColsVarargStringDocs
+
+    /** ## Cols
+     * Creates a subset of columns ([ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]) from [this].
+     *
+     * You can use either a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter], or any of the `vararg` overloads for any
+     * [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]. The function can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index (range)).
+     *
+     * This function operates solely on columns at the top-level.
+     *
+     * Aside from calling [cols][org.jetbrains.kotlinx.dataframe.api.ColsColumnsSelectionDsl.cols] directly, you can also use the [`get`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.get] operator in most cases.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColsColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     * `df.`[`remove`][org.jetbrains.kotlinx.dataframe.DataFrame.remove]`  {  `[`cols`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]` { it.`[`hasNulls`][org.jetbrains.kotlinx.dataframe.DataColumn.hasNulls]`() } }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myGroupCol.`[`cols`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.cols]`(columnA, columnB) }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[`colsOf`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[`String`][String]`>()`[`[`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.cols]`1, 3, 5`[`]`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.cols]` }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[`cols`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.cols]`("columnA", "columnB") }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup`[`[`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.cols]`"columnA", "columnB"`[`]`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.cols]` }`
+     *
+     *
+     * @param [firstCol] A [String] that points to a relative column.
+     * @param [otherCols] Optional additional [String]s that point to relative columns.
+     * @throws [IllegalArgumentException] if any of the given [ColumnReference][org.jetbrains.kotlinx.dataframe.columns.ColumnReference]s point to a column that doesn't
+     *   exist.
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing the columns that [firstCol] and [otherCols] point to.
+     */
+    @Suppress("INAPPLICABLE_JVM_NAME")
+    @JvmName("colsUnTyped")
+    public fun SingleColumn<DataRow<*>>.cols(firstCol: String, vararg otherCols: String): ColumnSet<*> =
+        cols<Any?>(firstCol, *otherCols)
+
+    /** ## Cols
+     * Creates a subset of columns ([ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]) from [this].
+     *
+     * You can use either a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter], or any of the `vararg` overloads for any
+     * [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]. The function can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index (range)).
+     *
+     * This function operates solely on columns at the top-level.
+     *
+     * Aside from calling [cols][org.jetbrains.kotlinx.dataframe.api.ColsColumnsSelectionDsl.cols] directly, you can also use the [`get`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.get] operator in most cases.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColsColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     * `df.`[`remove`][org.jetbrains.kotlinx.dataframe.DataFrame.remove]`  {  `[`cols`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]` { it.`[`hasNulls`][org.jetbrains.kotlinx.dataframe.DataColumn.hasNulls]`() } }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myGroupCol.`[`cols`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.cols]`(columnA, columnB) }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[`colsOf`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[`String`][String]`>()`[`[`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.cols]`1, 3, 5`[`]`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.cols]` }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[`cols`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.cols]`("columnA", "columnB") }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup`[`[`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.cols]`"columnA", "columnB"`[`]`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.cols]` }`
+     *
+     *
+     * @param [firstCol] A [String] that points to a relative column.
+     * @param [otherCols] Optional additional [String]s that point to relative columns.
+     * @throws [IllegalArgumentException] if any of the given [ColumnReference][org.jetbrains.kotlinx.dataframe.columns.ColumnReference]s point to a column that doesn't
+     *   exist.
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing the columns that [firstCol] and [otherCols] point to.
+     */
+    public fun <T> SingleColumn<DataRow<*>>.cols(firstCol: String, vararg otherCols: String): ColumnSet<T> =
+        colsInternal(listOf(firstCol, *otherCols).map { pathOf(it) }).cast()
+
+    /**
+     * ## Cols
+     * Creates a subset of columns ([ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]) from [this].
+     *
+     * You can use either a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter], or any of the `vararg` overloads for any
+     * [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]. The function can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index (range)).
+     *
+     * This function operates solely on columns at the top-level.
+     *
+     * Aside from calling [cols][org.jetbrains.kotlinx.dataframe.api.ColsColumnsSelectionDsl.cols] directly, you can also use the [`get`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.get] operator in most cases.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColsColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     * `df.`[`remove`][org.jetbrains.kotlinx.dataframe.DataFrame.remove]`  {  `[`cols`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]` { it.`[`hasNulls`][org.jetbrains.kotlinx.dataframe.DataColumn.hasNulls]`() } }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myGroupCol.`[`cols`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.cols]`(columnA, columnB) }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[`colsOf`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[`String`][String]`>()`[`[`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.cols]`1, 3, 5`[`]`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.cols]` }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[`cols`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.cols]`("columnA", "columnB") }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup`[`[`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.cols]`"columnA", "columnB"`[`]`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.cols]` }`
+     *
+     *
+     * @param [firstCol] A [String] that points to a relative column.
+     * @param [otherCols] Optional additional [String]s that point to relative columns.
+     * @throws [IllegalArgumentException] if any of the given [ColumnReference][org.jetbrains.kotlinx.dataframe.columns.ColumnReference]s point to a column that doesn't
+     *   exist.
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing the columns that [firstCol] and [otherCols] point to.
+     */
+    public operator fun SingleColumn<DataRow<*>>.get(firstCol: String, vararg otherCols: String): ColumnSet<*> =
+        cols<Any?>(firstCol, *otherCols)
+
+    /**
+     * ## Cols
+     * Creates a subset of columns ([ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]) from [this].
+     *
+     * You can use either a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter], or any of the `vararg` overloads for any
+     * [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]. The function can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index (range)).
+     *
+     * This function operates solely on columns at the top-level.
+     *
+     * Aside from calling [cols][org.jetbrains.kotlinx.dataframe.api.ColsColumnsSelectionDsl.cols] directly, you can also use the [`get`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.get] operator in most cases.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColsColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     * `df.`[`remove`][org.jetbrains.kotlinx.dataframe.DataFrame.remove]`  {  `[`cols`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]` { it.`[`hasNulls`][org.jetbrains.kotlinx.dataframe.DataColumn.hasNulls]`() } }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myGroupCol.`[`cols`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.cols]`(columnA, columnB) }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[`colsOf`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[`String`][String]`>()`[`[`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.cols]`1, 3, 5`[`]`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.cols]` }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[`select`][DataFrame.select]` { "columnGroup".`[`cols`][String.cols]`("columnA", "columnB") }`
+     *
+     * `df.`[`select`][DataFrame.select]` { "columnGroup"`[`[`][String.cols]`"columnA", "columnB"`[`]`][String.cols]` }`
+     *
+     *
+     * @param [firstCol] A [String] that points to a relative column.
+     * @param [otherCols] Optional additional [String]s that point to relative columns.
+     * @throws [IllegalArgumentException] if any of the given [ColumnReference][org.jetbrains.kotlinx.dataframe.columns.ColumnReference]s point to a column that doesn't
+     *   exist.
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing the columns that [firstCol] and [otherCols] point to.
+     */
+    private interface StringColsVarargStringDocs
+
+    /** ## Cols
+     * Creates a subset of columns ([ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]) from [this].
+     *
+     * You can use either a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter], or any of the `vararg` overloads for any
+     * [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]. The function can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index (range)).
+     *
+     * This function operates solely on columns at the top-level.
+     *
+     * Aside from calling [cols][org.jetbrains.kotlinx.dataframe.api.ColsColumnsSelectionDsl.cols] directly, you can also use the [`get`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.get] operator in most cases.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColsColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     * `df.`[`remove`][org.jetbrains.kotlinx.dataframe.DataFrame.remove]`  {  `[`cols`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]` { it.`[`hasNulls`][org.jetbrains.kotlinx.dataframe.DataColumn.hasNulls]`() } }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myGroupCol.`[`cols`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.cols]`(columnA, columnB) }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[`colsOf`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[`String`][String]`>()`[`[`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.cols]`1, 3, 5`[`]`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.cols]` }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "columnGroup".`[`cols`][kotlin.String.cols]`("columnA", "columnB") }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "columnGroup"`[`[`][kotlin.String.cols]`"columnA", "columnB"`[`]`][kotlin.String.cols]` }`
+     *
+     *
+     * @param [firstCol] A [String] that points to a relative column.
+     * @param [otherCols] Optional additional [String]s that point to relative columns.
+     * @throws [IllegalArgumentException] if any of the given [ColumnReference][org.jetbrains.kotlinx.dataframe.columns.ColumnReference]s point to a column that doesn't
+     *   exist.
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing the columns that [firstCol] and [otherCols] point to.
+     */
+    @Suppress("INAPPLICABLE_JVM_NAME")
+    @JvmName("colsUnTyped")
+    public fun String.cols(firstCol: String, vararg otherCols: String): ColumnSet<*> = cols<Any?>(firstCol, *otherCols)
+
+    /** ## Cols
+     * Creates a subset of columns ([ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]) from [this].
+     *
+     * You can use either a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter], or any of the `vararg` overloads for any
+     * [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]. The function can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index (range)).
+     *
+     * This function operates solely on columns at the top-level.
+     *
+     * Aside from calling [cols][org.jetbrains.kotlinx.dataframe.api.ColsColumnsSelectionDsl.cols] directly, you can also use the [`get`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.get] operator in most cases.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColsColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     * `df.`[`remove`][org.jetbrains.kotlinx.dataframe.DataFrame.remove]`  {  `[`cols`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]` { it.`[`hasNulls`][org.jetbrains.kotlinx.dataframe.DataColumn.hasNulls]`() } }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myGroupCol.`[`cols`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.cols]`(columnA, columnB) }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[`colsOf`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[`String`][String]`>()`[`[`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.cols]`1, 3, 5`[`]`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.cols]` }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "columnGroup".`[`cols`][kotlin.String.cols]`("columnA", "columnB") }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "columnGroup"`[`[`][kotlin.String.cols]`"columnA", "columnB"`[`]`][kotlin.String.cols]` }`
+     *
+     *
+     * @param [firstCol] A [String] that points to a relative column.
+     * @param [otherCols] Optional additional [String]s that point to relative columns.
+     * @throws [IllegalArgumentException] if any of the given [ColumnReference][org.jetbrains.kotlinx.dataframe.columns.ColumnReference]s point to a column that doesn't
+     *   exist.
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing the columns that [firstCol] and [otherCols] point to.
+     */
+    public fun <T> String.cols(firstCol: String, vararg otherCols: String): ColumnSet<T> =
+        columnGroup(this).cols(firstCol, *otherCols).cast()
+
+    /** ## Cols
+     * Creates a subset of columns ([ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]) from [this].
+     *
+     * You can use either a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter], or any of the `vararg` overloads for any
+     * [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]. The function can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index (range)).
+     *
+     * This function operates solely on columns at the top-level.
+     *
+     * Aside from calling [cols][org.jetbrains.kotlinx.dataframe.api.ColsColumnsSelectionDsl.cols] directly, you can also use the [`get`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.get] operator in most cases.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColsColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     * `df.`[`remove`][org.jetbrains.kotlinx.dataframe.DataFrame.remove]`  {  `[`cols`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]` { it.`[`hasNulls`][org.jetbrains.kotlinx.dataframe.DataColumn.hasNulls]`() } }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myGroupCol.`[`cols`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.cols]`(columnA, columnB) }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[`colsOf`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[`String`][String]`>()`[`[`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.cols]`1, 3, 5`[`]`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.cols]` }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "columnGroup".`[`cols`][kotlin.String.cols]`("columnA", "columnB") }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "columnGroup"`[`[`][kotlin.String.cols]`"columnA", "columnB"`[`]`][kotlin.String.cols]` }`
+     *
+     *
+     * @param [firstCol] A [String] that points to a relative column.
+     * @param [otherCols] Optional additional [String]s that point to relative columns.
+     * @throws [IllegalArgumentException] if any of the given [ColumnReference][org.jetbrains.kotlinx.dataframe.columns.ColumnReference]s point to a column that doesn't
+     *   exist.
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing the columns that [firstCol] and [otherCols] point to.
+     */
+    public operator fun String.get(firstCol: String, vararg otherCols: String): ColumnSet<*> =
+        cols<Any?>(firstCol, *otherCols)
+
+    /**
+     * ## Cols
+     * Creates a subset of columns ([ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]) from [this].
+     *
+     * You can use either a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter], or any of the `vararg` overloads for any
+     * [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]. The function can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index (range)).
+     *
+     * This function operates solely on columns at the top-level.
+     *
+     * Aside from calling [cols][org.jetbrains.kotlinx.dataframe.api.ColsColumnsSelectionDsl.cols] directly, you can also use the [`get`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.get] operator in most cases.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColsColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     * `df.`[`remove`][org.jetbrains.kotlinx.dataframe.DataFrame.remove]`  {  `[`cols`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]` { it.`[`hasNulls`][org.jetbrains.kotlinx.dataframe.DataColumn.hasNulls]`() } }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myGroupCol.`[`cols`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.cols]`(columnA, columnB) }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[`colsOf`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[`String`][String]`>()`[`[`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.cols]`1, 3, 5`[`]`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.cols]` }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[`select`][DataFrame.select]` { Type::myColumnGroup.`[`cols`][KProperty.cols]`("columnA", "columnB") }`
+     *
+     * `df.`[`select`][DataFrame.select]` { DataSchemaType::myColumnGroup`[`[`][KProperty.cols]`"columnA", "columnB"`[`]`][KProperty.cols]` }`
+     *
+     *
+     * @param [firstCol] A [String] that points to a relative column.
+     * @param [otherCols] Optional additional [String]s that point to relative columns.
+     * @throws [IllegalArgumentException] if any of the given [ColumnReference][org.jetbrains.kotlinx.dataframe.columns.ColumnReference]s point to a column that doesn't
+     *   exist.
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing the columns that [firstCol] and [otherCols] point to.
+     */
+    private interface KPropertiesColsVarargStringDocs
+
+    /** ## Cols
+     * Creates a subset of columns ([ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]) from [this].
+     *
+     * You can use either a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter], or any of the `vararg` overloads for any
+     * [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]. The function can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index (range)).
+     *
+     * This function operates solely on columns at the top-level.
+     *
+     * Aside from calling [cols][org.jetbrains.kotlinx.dataframe.api.ColsColumnsSelectionDsl.cols] directly, you can also use the [`get`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.get] operator in most cases.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColsColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     * `df.`[`remove`][org.jetbrains.kotlinx.dataframe.DataFrame.remove]`  {  `[`cols`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]` { it.`[`hasNulls`][org.jetbrains.kotlinx.dataframe.DataColumn.hasNulls]`() } }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myGroupCol.`[`cols`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.cols]`(columnA, columnB) }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[`colsOf`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[`String`][String]`>()`[`[`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.cols]`1, 3, 5`[`]`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.cols]` }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { Type::myColumnGroup.`[`cols`][kotlin.reflect.KProperty.cols]`("columnA", "columnB") }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { DataSchemaType::myColumnGroup`[`[`][kotlin.reflect.KProperty.cols]`"columnA", "columnB"`[`]`][kotlin.reflect.KProperty.cols]` }`
+     *
+     *
+     * @param [firstCol] A [String] that points to a relative column.
+     * @param [otherCols] Optional additional [String]s that point to relative columns.
+     * @throws [IllegalArgumentException] if any of the given [ColumnReference][org.jetbrains.kotlinx.dataframe.columns.ColumnReference]s point to a column that doesn't
+     *   exist.
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing the columns that [firstCol] and [otherCols] point to.
+     */
+    @Suppress("INAPPLICABLE_JVM_NAME")
+    @JvmName("colsUnTyped")
+    public fun KProperty<*>.cols(firstCol: String, vararg otherCols: String): ColumnSet<*> =
+        cols<Any?>(firstCol, *otherCols)
+
+    /** ## Cols
+     * Creates a subset of columns ([ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]) from [this].
+     *
+     * You can use either a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter], or any of the `vararg` overloads for any
+     * [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]. The function can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index (range)).
+     *
+     * This function operates solely on columns at the top-level.
+     *
+     * Aside from calling [cols][org.jetbrains.kotlinx.dataframe.api.ColsColumnsSelectionDsl.cols] directly, you can also use the [`get`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.get] operator in most cases.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColsColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     * `df.`[`remove`][org.jetbrains.kotlinx.dataframe.DataFrame.remove]`  {  `[`cols`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]` { it.`[`hasNulls`][org.jetbrains.kotlinx.dataframe.DataColumn.hasNulls]`() } }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myGroupCol.`[`cols`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.cols]`(columnA, columnB) }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[`colsOf`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[`String`][String]`>()`[`[`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.cols]`1, 3, 5`[`]`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.cols]` }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { Type::myColumnGroup.`[`cols`][kotlin.reflect.KProperty.cols]`("columnA", "columnB") }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { DataSchemaType::myColumnGroup`[`[`][kotlin.reflect.KProperty.cols]`"columnA", "columnB"`[`]`][kotlin.reflect.KProperty.cols]` }`
+     *
+     *
+     * @param [firstCol] A [String] that points to a relative column.
+     * @param [otherCols] Optional additional [String]s that point to relative columns.
+     * @throws [IllegalArgumentException] if any of the given [ColumnReference][org.jetbrains.kotlinx.dataframe.columns.ColumnReference]s point to a column that doesn't
+     *   exist.
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing the columns that [firstCol] and [otherCols] point to.
+     */
+    public fun <T> KProperty<*>.cols(firstCol: String, vararg otherCols: String): ColumnSet<T> =
+        columnGroup(this).cols(firstCol, *otherCols).cast()
+
+    /** ## Cols
+     * Creates a subset of columns ([ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]) from [this].
+     *
+     * You can use either a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter], or any of the `vararg` overloads for any
+     * [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]. The function can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index (range)).
+     *
+     * This function operates solely on columns at the top-level.
+     *
+     * Aside from calling [cols][org.jetbrains.kotlinx.dataframe.api.ColsColumnsSelectionDsl.cols] directly, you can also use the [`get`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.get] operator in most cases.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColsColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     * `df.`[`remove`][org.jetbrains.kotlinx.dataframe.DataFrame.remove]`  {  `[`cols`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]` { it.`[`hasNulls`][org.jetbrains.kotlinx.dataframe.DataColumn.hasNulls]`() } }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myGroupCol.`[`cols`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.cols]`(columnA, columnB) }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[`colsOf`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[`String`][String]`>()`[`[`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.cols]`1, 3, 5`[`]`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.cols]` }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { Type::myColumnGroup.`[`cols`][kotlin.reflect.KProperty.cols]`("columnA", "columnB") }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { DataSchemaType::myColumnGroup`[`[`][kotlin.reflect.KProperty.cols]`"columnA", "columnB"`[`]`][kotlin.reflect.KProperty.cols]` }`
+     *
+     *
+     * @param [firstCol] A [String] that points to a relative column.
+     * @param [otherCols] Optional additional [String]s that point to relative columns.
+     * @throws [IllegalArgumentException] if any of the given [ColumnReference][org.jetbrains.kotlinx.dataframe.columns.ColumnReference]s point to a column that doesn't
+     *   exist.
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing the columns that [firstCol] and [otherCols] point to.
+     */
+    public operator fun KProperty<*>.get(firstCol: String, vararg otherCols: String): ColumnSet<*> =
+        cols<Any?>(firstCol, *otherCols)
+
+    /**
+     * ## Cols
+     * Creates a subset of columns ([ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]) from [this].
+     *
+     * You can use either a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter], or any of the `vararg` overloads for any
+     * [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]. The function can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index (range)).
+     *
+     * This function operates solely on columns at the top-level.
+     *
+     * Aside from calling [cols][org.jetbrains.kotlinx.dataframe.api.ColsColumnsSelectionDsl.cols] directly, you can also use the [`get`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.get] operator in most cases.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColsColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     * `df.`[`remove`][org.jetbrains.kotlinx.dataframe.DataFrame.remove]`  {  `[`cols`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]` { it.`[`hasNulls`][org.jetbrains.kotlinx.dataframe.DataColumn.hasNulls]`() } }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myGroupCol.`[`cols`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.cols]`(columnA, columnB) }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[`colsOf`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[`String`][String]`>()`[`[`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.cols]`1, 3, 5`[`]`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.cols]` }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[`select`][DataFrame.select]` { "pathTo"["columnGroup"].`[`cols`][ColumnPath.cols]`("columnA", "columnB") }`
+     *
+     * `df.`[`select`][DataFrame.select]` { "pathTo"["columnGroup"]`[`[`][ColumnPath.cols]`"columnA", "columnB"`[`]`][ColumnPath.cols]` }`
+     *
+     *
+     * @param [firstCol] A [String] that points to a relative column.
+     * @param [otherCols] Optional additional [String]s that point to relative columns.
+     * @throws [IllegalArgumentException] if any of the given [ColumnReference][org.jetbrains.kotlinx.dataframe.columns.ColumnReference]s point to a column that doesn't
+     *   exist.
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing the columns that [firstCol] and [otherCols] point to.
+     */
+    private interface ColumnPathColsVarargStringDocs
+
+    /** ## Cols
+     * Creates a subset of columns ([ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]) from [this].
+     *
+     * You can use either a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter], or any of the `vararg` overloads for any
+     * [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]. The function can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index (range)).
+     *
+     * This function operates solely on columns at the top-level.
+     *
+     * Aside from calling [cols][org.jetbrains.kotlinx.dataframe.api.ColsColumnsSelectionDsl.cols] directly, you can also use the [`get`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.get] operator in most cases.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColsColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     * `df.`[`remove`][org.jetbrains.kotlinx.dataframe.DataFrame.remove]`  {  `[`cols`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]` { it.`[`hasNulls`][org.jetbrains.kotlinx.dataframe.DataColumn.hasNulls]`() } }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myGroupCol.`[`cols`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.cols]`(columnA, columnB) }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[`colsOf`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[`String`][String]`>()`[`[`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.cols]`1, 3, 5`[`]`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.cols]` }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "pathTo"["columnGroup"].`[`cols`][org.jetbrains.kotlinx.dataframe.columns.ColumnPath.cols]`("columnA", "columnB") }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "pathTo"["columnGroup"]`[`[`][org.jetbrains.kotlinx.dataframe.columns.ColumnPath.cols]`"columnA", "columnB"`[`]`][org.jetbrains.kotlinx.dataframe.columns.ColumnPath.cols]` }`
+     *
+     *
+     * @param [firstCol] A [String] that points to a relative column.
+     * @param [otherCols] Optional additional [String]s that point to relative columns.
+     * @throws [IllegalArgumentException] if any of the given [ColumnReference][org.jetbrains.kotlinx.dataframe.columns.ColumnReference]s point to a column that doesn't
+     *   exist.
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing the columns that [firstCol] and [otherCols] point to.
+     */
+    @Suppress("INAPPLICABLE_JVM_NAME")
+    @JvmName("colsUnTyped")
+    public fun ColumnPath.cols(firstCol: String, vararg otherCols: String): ColumnSet<*> =
+        cols<Any?>(firstCol, *otherCols)
+
+    /** ## Cols
+     * Creates a subset of columns ([ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]) from [this].
+     *
+     * You can use either a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter], or any of the `vararg` overloads for any
+     * [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]. The function can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index (range)).
+     *
+     * This function operates solely on columns at the top-level.
+     *
+     * Aside from calling [cols][org.jetbrains.kotlinx.dataframe.api.ColsColumnsSelectionDsl.cols] directly, you can also use the [`get`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.get] operator in most cases.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColsColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     * `df.`[`remove`][org.jetbrains.kotlinx.dataframe.DataFrame.remove]`  {  `[`cols`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]` { it.`[`hasNulls`][org.jetbrains.kotlinx.dataframe.DataColumn.hasNulls]`() } }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myGroupCol.`[`cols`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.cols]`(columnA, columnB) }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[`colsOf`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[`String`][String]`>()`[`[`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.cols]`1, 3, 5`[`]`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.cols]` }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "pathTo"["columnGroup"].`[`cols`][org.jetbrains.kotlinx.dataframe.columns.ColumnPath.cols]`("columnA", "columnB") }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "pathTo"["columnGroup"]`[`[`][org.jetbrains.kotlinx.dataframe.columns.ColumnPath.cols]`"columnA", "columnB"`[`]`][org.jetbrains.kotlinx.dataframe.columns.ColumnPath.cols]` }`
+     *
+     *
+     * @param [firstCol] A [String] that points to a relative column.
+     * @param [otherCols] Optional additional [String]s that point to relative columns.
+     * @throws [IllegalArgumentException] if any of the given [ColumnReference][org.jetbrains.kotlinx.dataframe.columns.ColumnReference]s point to a column that doesn't
+     *   exist.
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing the columns that [firstCol] and [otherCols] point to.
+     */
+    public fun <T> ColumnPath.cols(firstCol: String, vararg otherCols: String): ColumnSet<T> =
+        columnGroup(this).cols(firstCol, *otherCols).cast()
+
+    /** ## Cols
+     * Creates a subset of columns ([ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]) from [this].
+     *
+     * You can use either a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter], or any of the `vararg` overloads for any
+     * [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]. The function can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index (range)).
+     *
+     * This function operates solely on columns at the top-level.
+     *
+     * Aside from calling [cols][org.jetbrains.kotlinx.dataframe.api.ColsColumnsSelectionDsl.cols] directly, you can also use the [`get`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.get] operator in most cases.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColsColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     * `df.`[`remove`][org.jetbrains.kotlinx.dataframe.DataFrame.remove]`  {  `[`cols`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]` { it.`[`hasNulls`][org.jetbrains.kotlinx.dataframe.DataColumn.hasNulls]`() } }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myGroupCol.`[`cols`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.cols]`(columnA, columnB) }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[`colsOf`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[`String`][String]`>()`[`[`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.cols]`1, 3, 5`[`]`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.cols]` }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "pathTo"["columnGroup"].`[`cols`][org.jetbrains.kotlinx.dataframe.columns.ColumnPath.cols]`("columnA", "columnB") }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "pathTo"["columnGroup"]`[`[`][org.jetbrains.kotlinx.dataframe.columns.ColumnPath.cols]`"columnA", "columnB"`[`]`][org.jetbrains.kotlinx.dataframe.columns.ColumnPath.cols]` }`
+     *
+     *
+     * @param [firstCol] A [String] that points to a relative column.
+     * @param [otherCols] Optional additional [String]s that point to relative columns.
+     * @throws [IllegalArgumentException] if any of the given [ColumnReference][org.jetbrains.kotlinx.dataframe.columns.ColumnReference]s point to a column that doesn't
+     *   exist.
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing the columns that [firstCol] and [otherCols] point to.
+     */
+    public operator fun ColumnPath.get(firstCol: String, vararg otherCols: String): ColumnSet<*> =
+        cols<Any?>(firstCol, *otherCols)
+
+    // endregion
+
+    // region paths
+
+    /**
+     * ## Cols
+     * Creates a subset of columns ([ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]) from [this].
+     *
+     * You can use either a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter], or any of the `vararg` overloads for any
+     * [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]. The function can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index (range)).
+     *
+     * This function operates solely on columns at the top-level.
+     *
+     * Aside from calling [cols][org.jetbrains.kotlinx.dataframe.api.ColsColumnsSelectionDsl.cols] directly, you can also use the [`get`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.get] operator in most cases.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColsColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     * `df.`[`remove`][org.jetbrains.kotlinx.dataframe.DataFrame.remove]`  {  `[`cols`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]` { it.`[`hasNulls`][org.jetbrains.kotlinx.dataframe.DataColumn.hasNulls]`() } }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myGroupCol.`[`cols`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.cols]`(columnA, columnB) }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[`colsOf`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[`String`][String]`>()`[`[`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.cols]`1, 3, 5`[`]`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.cols]` }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[`select`][DataFrame.select]`  {  `[`cols`][ColumnsSelectionDsl.cols]`("pathTo"["colA"], "pathTo"["colB"])) }`
+     *
+     * `df.`[`select`][DataFrame.select]`  {  `[`cols`][ColumnsSelectionDsl.cols]`<`[`String`][String]`>("pathTo"["colA"], "pathTo"["colB"])) }`
+     *
+     * `df.`[`select`][DataFrame.select]` { this`[`[`][ColumnsSelectionDsl.cols]`"pathTo"["colA"], "pathTo"["colB"])`[`]`][ColumnsSelectionDsl.cols]` }`
+     *
+     *
+     * @param [firstCol] A [String] that points to a relative column.
+     * @param [otherCols] Optional additional [String]s that point to relative columns.
+     * @throws [IllegalArgumentException] if any of the given [ColumnReference][org.jetbrains.kotlinx.dataframe.columns.ColumnReference]s point to a column that doesn't
+     *   exist.
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing the columns that [firstCol] and [otherCols] point to.
+     */
+    private interface ColumnsSelectionDslVarargColumnPathDocs
+
+    /** ## Cols
+     * Creates a subset of columns ([ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]) from [this].
+     *
+     * You can use either a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter], or any of the `vararg` overloads for any
+     * [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]. The function can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index (range)).
+     *
+     * This function operates solely on columns at the top-level.
+     *
+     * Aside from calling [cols][org.jetbrains.kotlinx.dataframe.api.ColsColumnsSelectionDsl.cols] directly, you can also use the [`get`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.get] operator in most cases.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColsColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     * `df.`[`remove`][org.jetbrains.kotlinx.dataframe.DataFrame.remove]`  {  `[`cols`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]` { it.`[`hasNulls`][org.jetbrains.kotlinx.dataframe.DataColumn.hasNulls]`() } }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myGroupCol.`[`cols`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.cols]`(columnA, columnB) }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[`colsOf`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[`String`][String]`>()`[`[`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.cols]`1, 3, 5`[`]`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.cols]` }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[`cols`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`("pathTo"["colA"], "pathTo"["colB"])) }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[`cols`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`<`[`String`][String]`>("pathTo"["colA"], "pathTo"["colB"])) }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { this`[`[`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`"pathTo"["colA"], "pathTo"["colB"])`[`]`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]` }`
+     *
+     *
+     * @param [firstCol] A [String] that points to a relative column.
+     * @param [otherCols] Optional additional [String]s that point to relative columns.
+     * @throws [IllegalArgumentException] if any of the given [ColumnReference][org.jetbrains.kotlinx.dataframe.columns.ColumnReference]s point to a column that doesn't
+     *   exist.
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing the columns that [firstCol] and [otherCols] point to.
+     */
+    @Suppress("INAPPLICABLE_JVM_NAME")
+    @JvmName("colsUnTyped")
+    public fun ColumnsSelectionDsl<*>.cols(firstCol: ColumnPath, vararg otherCols: ColumnPath): ColumnSet<*> =
+        cols<Any?>(firstCol, *otherCols)
+
+    /** ## Cols
+     * Creates a subset of columns ([ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]) from [this].
+     *
+     * You can use either a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter], or any of the `vararg` overloads for any
+     * [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]. The function can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index (range)).
+     *
+     * This function operates solely on columns at the top-level.
+     *
+     * Aside from calling [cols][org.jetbrains.kotlinx.dataframe.api.ColsColumnsSelectionDsl.cols] directly, you can also use the [`get`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.get] operator in most cases.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColsColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     * `df.`[`remove`][org.jetbrains.kotlinx.dataframe.DataFrame.remove]`  {  `[`cols`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]` { it.`[`hasNulls`][org.jetbrains.kotlinx.dataframe.DataColumn.hasNulls]`() } }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myGroupCol.`[`cols`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.cols]`(columnA, columnB) }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[`colsOf`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[`String`][String]`>()`[`[`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.cols]`1, 3, 5`[`]`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.cols]` }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[`cols`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`("pathTo"["colA"], "pathTo"["colB"])) }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[`cols`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`<`[`String`][String]`>("pathTo"["colA"], "pathTo"["colB"])) }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { this`[`[`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`"pathTo"["colA"], "pathTo"["colB"])`[`]`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]` }`
+     *
+     *
+     * @param [firstCol] A [String] that points to a relative column.
+     * @param [otherCols] Optional additional [String]s that point to relative columns.
+     * @throws [IllegalArgumentException] if any of the given [ColumnReference][org.jetbrains.kotlinx.dataframe.columns.ColumnReference]s point to a column that doesn't
+     *   exist.
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing the columns that [firstCol] and [otherCols] point to.
+     */
+    public fun <T> ColumnsSelectionDsl<*>.cols(firstCol: ColumnPath, vararg otherCols: ColumnPath): ColumnSet<T> =
+        asSingleColumn().cols<T>(firstCol, *otherCols)
+
+    /** ## Cols
+     * Creates a subset of columns ([ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]) from [this].
+     *
+     * You can use either a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter], or any of the `vararg` overloads for any
+     * [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]. The function can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index (range)).
+     *
+     * This function operates solely on columns at the top-level.
+     *
+     * Aside from calling [cols][org.jetbrains.kotlinx.dataframe.api.ColsColumnsSelectionDsl.cols] directly, you can also use the [`get`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.get] operator in most cases.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColsColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     * `df.`[`remove`][org.jetbrains.kotlinx.dataframe.DataFrame.remove]`  {  `[`cols`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]` { it.`[`hasNulls`][org.jetbrains.kotlinx.dataframe.DataColumn.hasNulls]`() } }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myGroupCol.`[`cols`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.cols]`(columnA, columnB) }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[`colsOf`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[`String`][String]`>()`[`[`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.cols]`1, 3, 5`[`]`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.cols]` }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[`cols`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`("pathTo"["colA"], "pathTo"["colB"])) }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[`cols`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`<`[`String`][String]`>("pathTo"["colA"], "pathTo"["colB"])) }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { this`[`[`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`"pathTo"["colA"], "pathTo"["colB"])`[`]`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]` }`
+     *
+     *
+     * @param [firstCol] A [String] that points to a relative column.
+     * @param [otherCols] Optional additional [String]s that point to relative columns.
+     * @throws [IllegalArgumentException] if any of the given [ColumnReference][org.jetbrains.kotlinx.dataframe.columns.ColumnReference]s point to a column that doesn't
+     *   exist.
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing the columns that [firstCol] and [otherCols] point to.
+     */
+    public operator fun ColumnsSelectionDsl<*>.get(firstCol: ColumnPath, vararg otherCols: ColumnPath): ColumnSet<*> =
+        cols<Any?>(firstCol, *otherCols)
+
+    /**
+     * ## Cols
+     * Creates a subset of columns ([ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]) from [this].
+     *
+     * You can use either a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter], or any of the `vararg` overloads for any
+     * [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]. The function can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index (range)).
+     *
+     * This function operates solely on columns at the top-level.
+     *
+     * Aside from calling [cols][org.jetbrains.kotlinx.dataframe.api.ColsColumnsSelectionDsl.cols] directly, you can also use the [`get`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.get] operator in most cases.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColsColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     * `df.`[`remove`][org.jetbrains.kotlinx.dataframe.DataFrame.remove]`  {  `[`cols`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]` { it.`[`hasNulls`][org.jetbrains.kotlinx.dataframe.DataColumn.hasNulls]`() } }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myGroupCol.`[`cols`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.cols]`(columnA, columnB) }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[`colsOf`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[`String`][String]`>()`[`[`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.cols]`1, 3, 5`[`]`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.cols]` }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[`select`][DataFrame.select]` { myColumnGroup.`[`cols`][SingleColumn.cols]`("pathTo"["colA"], "pathTo"["colB"])) }`
+     *
+     * `df.`[`select`][DataFrame.select]` { myColumnGroup.`[`cols`][SingleColumn.cols]`<`[`String`][String]`>("pathTo"["colA"], "pathTo"["colB"])) }`
+     *
+     * `df.`[`select`][DataFrame.select]` { myColumnGroup`[`[`][SingleColumn.cols]`"pathTo"["colA"], "pathTo"["colB"])`[`]`][SingleColumn.cols]` }`
+     *
+     *
+     * @param [firstCol] A [ColumnPath] that points to a relative column.
+     * @param [otherCols] Optional additional [ColumnPath]s that point to relative columns.
+     * @throws [IllegalArgumentException] if any of the given [ColumnReference][org.jetbrains.kotlinx.dataframe.columns.ColumnReference]s point to a column that doesn't
+     *   exist.
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing the columns that [firstCol] and [otherCols] point to.
+     */
+    private interface SingleColumnColsVarargColumnPathDocs
+
+    /** ## Cols
+     * Creates a subset of columns ([ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]) from [this].
+     *
+     * You can use either a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter], or any of the `vararg` overloads for any
+     * [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]. The function can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index (range)).
+     *
+     * This function operates solely on columns at the top-level.
+     *
+     * Aside from calling [cols][org.jetbrains.kotlinx.dataframe.api.ColsColumnsSelectionDsl.cols] directly, you can also use the [`get`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.get] operator in most cases.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColsColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     * `df.`[`remove`][org.jetbrains.kotlinx.dataframe.DataFrame.remove]`  {  `[`cols`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]` { it.`[`hasNulls`][org.jetbrains.kotlinx.dataframe.DataColumn.hasNulls]`() } }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myGroupCol.`[`cols`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.cols]`(columnA, columnB) }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[`colsOf`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[`String`][String]`>()`[`[`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.cols]`1, 3, 5`[`]`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.cols]` }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[`cols`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.cols]`("pathTo"["colA"], "pathTo"["colB"])) }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[`cols`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.cols]`<`[`String`][String]`>("pathTo"["colA"], "pathTo"["colB"])) }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup`[`[`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.cols]`"pathTo"["colA"], "pathTo"["colB"])`[`]`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.cols]` }`
+     *
+     *
+     * @param [firstCol] A [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath] that points to a relative column.
+     * @param [otherCols] Optional additional [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath]s that point to relative columns.
+     * @throws [IllegalArgumentException] if any of the given [ColumnReference][org.jetbrains.kotlinx.dataframe.columns.ColumnReference]s point to a column that doesn't
+     *   exist.
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing the columns that [firstCol] and [otherCols] point to.
+     */
+    @Suppress("INAPPLICABLE_JVM_NAME")
+    @JvmName("colsUnTyped")
+    public fun SingleColumn<DataRow<*>>.cols(firstCol: ColumnPath, vararg otherCols: ColumnPath): ColumnSet<*> =
+        cols<Any?>(firstCol, *otherCols)
+
+    /** ## Cols
+     * Creates a subset of columns ([ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]) from [this].
+     *
+     * You can use either a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter], or any of the `vararg` overloads for any
+     * [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]. The function can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index (range)).
+     *
+     * This function operates solely on columns at the top-level.
+     *
+     * Aside from calling [cols][org.jetbrains.kotlinx.dataframe.api.ColsColumnsSelectionDsl.cols] directly, you can also use the [`get`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.get] operator in most cases.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColsColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     * `df.`[`remove`][org.jetbrains.kotlinx.dataframe.DataFrame.remove]`  {  `[`cols`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]` { it.`[`hasNulls`][org.jetbrains.kotlinx.dataframe.DataColumn.hasNulls]`() } }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myGroupCol.`[`cols`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.cols]`(columnA, columnB) }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[`colsOf`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[`String`][String]`>()`[`[`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.cols]`1, 3, 5`[`]`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.cols]` }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[`cols`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.cols]`("pathTo"["colA"], "pathTo"["colB"])) }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[`cols`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.cols]`<`[`String`][String]`>("pathTo"["colA"], "pathTo"["colB"])) }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup`[`[`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.cols]`"pathTo"["colA"], "pathTo"["colB"])`[`]`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.cols]` }`
+     *
+     *
+     * @param [firstCol] A [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath] that points to a relative column.
+     * @param [otherCols] Optional additional [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath]s that point to relative columns.
+     * @throws [IllegalArgumentException] if any of the given [ColumnReference][org.jetbrains.kotlinx.dataframe.columns.ColumnReference]s point to a column that doesn't
+     *   exist.
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing the columns that [firstCol] and [otherCols] point to.
+     */
+    public fun <T> SingleColumn<DataRow<*>>.cols(firstCol: ColumnPath, vararg otherCols: ColumnPath): ColumnSet<T> =
+        colsInternal(listOf(firstCol, *otherCols)).cast()
+
+    /**
+     * ## Cols
+     * Creates a subset of columns ([ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]) from [this].
+     *
+     * You can use either a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter], or any of the `vararg` overloads for any
+     * [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]. The function can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index (range)).
+     *
+     * This function operates solely on columns at the top-level.
+     *
+     * Aside from calling [cols][org.jetbrains.kotlinx.dataframe.api.ColsColumnsSelectionDsl.cols] directly, you can also use the [`get`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.get] operator in most cases.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColsColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     * `df.`[`remove`][org.jetbrains.kotlinx.dataframe.DataFrame.remove]`  {  `[`cols`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]` { it.`[`hasNulls`][org.jetbrains.kotlinx.dataframe.DataColumn.hasNulls]`() } }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myGroupCol.`[`cols`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.cols]`(columnA, columnB) }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[`colsOf`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[`String`][String]`>()`[`[`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.cols]`1, 3, 5`[`]`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.cols]` }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[`cols`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.cols]`("pathTo"["colA"], "pathTo"["colB"])) }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[`cols`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.cols]`<`[`String`][String]`>("pathTo"["colA"], "pathTo"["colB"])) }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup`[`[`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.cols]`"pathTo"["colA"], "pathTo"["colB"])`[`]`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.cols]` }`
+     *
+     *
+     * @param [firstCol] A [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath] that points to a relative column.
+     * @param [otherCols] Optional additional [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath]s that point to relative columns.
+     * @throws [IllegalArgumentException] if any of the given [ColumnReference][org.jetbrains.kotlinx.dataframe.columns.ColumnReference]s point to a column that doesn't
+     *   exist.
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing the columns that [firstCol] and [otherCols] point to.
+     */
+    public operator fun SingleColumn<DataRow<*>>.get(
+        firstCol: ColumnPath,
+        vararg otherCols: ColumnPath,
+    ): ColumnSet<*> = cols<Any?>(firstCol, *otherCols)
+
+    /**
+     * ## Cols
+     * Creates a subset of columns ([ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]) from [this].
+     *
+     * You can use either a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter], or any of the `vararg` overloads for any
+     * [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]. The function can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index (range)).
+     *
+     * This function operates solely on columns at the top-level.
+     *
+     * Aside from calling [cols][org.jetbrains.kotlinx.dataframe.api.ColsColumnsSelectionDsl.cols] directly, you can also use the [`get`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.get] operator in most cases.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColsColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     * `df.`[`remove`][org.jetbrains.kotlinx.dataframe.DataFrame.remove]`  {  `[`cols`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]` { it.`[`hasNulls`][org.jetbrains.kotlinx.dataframe.DataColumn.hasNulls]`() } }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myGroupCol.`[`cols`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.cols]`(columnA, columnB) }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[`colsOf`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[`String`][String]`>()`[`[`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.cols]`1, 3, 5`[`]`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.cols]` }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[`select`][DataFrame.select]` { "columnGroup".`[`cols`][String.cols]`("pathTo"["colA"], "pathTo"["colB"])) }`
+     *
+     * `df.`[`select`][DataFrame.select]` { "columnGroup".`[`cols`][String.cols]`<`[`String`][String]`>("pathTo"["colA"], "pathTo"["colB"])) }`
+     *
+     * `df.`[`select`][DataFrame.select]` { "columnGroup"`[`[`][String.cols]`""pathTo"["colA"], "pathTo"["colB"])`[`]`][ColumnPath.cols]` }`
+     *
+     *
+     * @param [firstCol] A [ColumnPath] that points to a relative column.
+     * @param [otherCols] Optional additional [ColumnPath]s that point to relative columns.
+     * @throws [IllegalArgumentException] if any of the given [ColumnReference][org.jetbrains.kotlinx.dataframe.columns.ColumnReference]s point to a column that doesn't
+     *   exist.
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing the columns that [firstCol] and [otherCols] point to.
+     */
+    private interface StringColsVarargColumnPathDocs
+
+    /** ## Cols
+     * Creates a subset of columns ([ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]) from [this].
+     *
+     * You can use either a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter], or any of the `vararg` overloads for any
+     * [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]. The function can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index (range)).
+     *
+     * This function operates solely on columns at the top-level.
+     *
+     * Aside from calling [cols][org.jetbrains.kotlinx.dataframe.api.ColsColumnsSelectionDsl.cols] directly, you can also use the [`get`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.get] operator in most cases.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColsColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     * `df.`[`remove`][org.jetbrains.kotlinx.dataframe.DataFrame.remove]`  {  `[`cols`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]` { it.`[`hasNulls`][org.jetbrains.kotlinx.dataframe.DataColumn.hasNulls]`() } }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myGroupCol.`[`cols`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.cols]`(columnA, columnB) }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[`colsOf`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[`String`][String]`>()`[`[`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.cols]`1, 3, 5`[`]`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.cols]` }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "columnGroup".`[`cols`][kotlin.String.cols]`("pathTo"["colA"], "pathTo"["colB"])) }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "columnGroup".`[`cols`][kotlin.String.cols]`<`[`String`][String]`>("pathTo"["colA"], "pathTo"["colB"])) }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "columnGroup"`[`[`][kotlin.String.cols]`""pathTo"["colA"], "pathTo"["colB"])`[`]`][org.jetbrains.kotlinx.dataframe.columns.ColumnPath.cols]` }`
+     *
+     *
+     * @param [firstCol] A [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath] that points to a relative column.
+     * @param [otherCols] Optional additional [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath]s that point to relative columns.
+     * @throws [IllegalArgumentException] if any of the given [ColumnReference][org.jetbrains.kotlinx.dataframe.columns.ColumnReference]s point to a column that doesn't
+     *   exist.
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing the columns that [firstCol] and [otherCols] point to.
+     */
+    @Suppress("INAPPLICABLE_JVM_NAME")
+    @JvmName("colsUnTyped")
+    public fun String.cols(firstCol: ColumnPath, vararg otherCols: ColumnPath): ColumnSet<*> =
+        cols<Any?>(firstCol, *otherCols)
+
+    /** ## Cols
+     * Creates a subset of columns ([ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]) from [this].
+     *
+     * You can use either a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter], or any of the `vararg` overloads for any
+     * [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]. The function can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index (range)).
+     *
+     * This function operates solely on columns at the top-level.
+     *
+     * Aside from calling [cols][org.jetbrains.kotlinx.dataframe.api.ColsColumnsSelectionDsl.cols] directly, you can also use the [`get`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.get] operator in most cases.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColsColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     * `df.`[`remove`][org.jetbrains.kotlinx.dataframe.DataFrame.remove]`  {  `[`cols`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]` { it.`[`hasNulls`][org.jetbrains.kotlinx.dataframe.DataColumn.hasNulls]`() } }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myGroupCol.`[`cols`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.cols]`(columnA, columnB) }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[`colsOf`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[`String`][String]`>()`[`[`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.cols]`1, 3, 5`[`]`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.cols]` }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "columnGroup".`[`cols`][kotlin.String.cols]`("pathTo"["colA"], "pathTo"["colB"])) }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "columnGroup".`[`cols`][kotlin.String.cols]`<`[`String`][String]`>("pathTo"["colA"], "pathTo"["colB"])) }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "columnGroup"`[`[`][kotlin.String.cols]`""pathTo"["colA"], "pathTo"["colB"])`[`]`][org.jetbrains.kotlinx.dataframe.columns.ColumnPath.cols]` }`
+     *
+     *
+     * @param [firstCol] A [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath] that points to a relative column.
+     * @param [otherCols] Optional additional [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath]s that point to relative columns.
+     * @throws [IllegalArgumentException] if any of the given [ColumnReference][org.jetbrains.kotlinx.dataframe.columns.ColumnReference]s point to a column that doesn't
+     *   exist.
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing the columns that [firstCol] and [otherCols] point to.
+     */
+    public fun <T> String.cols(firstCol: ColumnPath, vararg otherCols: ColumnPath): ColumnSet<T> =
+        columnGroup(this).cols(firstCol, *otherCols).cast()
+
+    /** ## Cols
+     * Creates a subset of columns ([ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]) from [this].
+     *
+     * You can use either a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter], or any of the `vararg` overloads for any
+     * [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]. The function can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index (range)).
+     *
+     * This function operates solely on columns at the top-level.
+     *
+     * Aside from calling [cols][org.jetbrains.kotlinx.dataframe.api.ColsColumnsSelectionDsl.cols] directly, you can also use the [`get`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.get] operator in most cases.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColsColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     * `df.`[`remove`][org.jetbrains.kotlinx.dataframe.DataFrame.remove]`  {  `[`cols`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]` { it.`[`hasNulls`][org.jetbrains.kotlinx.dataframe.DataColumn.hasNulls]`() } }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myGroupCol.`[`cols`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.cols]`(columnA, columnB) }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[`colsOf`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[`String`][String]`>()`[`[`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.cols]`1, 3, 5`[`]`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.cols]` }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "columnGroup".`[`cols`][kotlin.String.cols]`("pathTo"["colA"], "pathTo"["colB"])) }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "columnGroup".`[`cols`][kotlin.String.cols]`<`[`String`][String]`>("pathTo"["colA"], "pathTo"["colB"])) }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "columnGroup"`[`[`][kotlin.String.cols]`""pathTo"["colA"], "pathTo"["colB"])`[`]`][org.jetbrains.kotlinx.dataframe.columns.ColumnPath.cols]` }`
+     *
+     *
+     * @param [firstCol] A [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath] that points to a relative column.
+     * @param [otherCols] Optional additional [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath]s that point to relative columns.
+     * @throws [IllegalArgumentException] if any of the given [ColumnReference][org.jetbrains.kotlinx.dataframe.columns.ColumnReference]s point to a column that doesn't
+     *   exist.
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing the columns that [firstCol] and [otherCols] point to.
+     */
+    public operator fun String.get(firstCol: ColumnPath, vararg otherCols: ColumnPath): ColumnSet<*> =
+        cols<Any?>(firstCol, *otherCols)
+
+    /**
+     * ## Cols
+     * Creates a subset of columns ([ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]) from [this].
+     *
+     * You can use either a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter], or any of the `vararg` overloads for any
+     * [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]. The function can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index (range)).
+     *
+     * This function operates solely on columns at the top-level.
+     *
+     * Aside from calling [cols][org.jetbrains.kotlinx.dataframe.api.ColsColumnsSelectionDsl.cols] directly, you can also use the [`get`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.get] operator in most cases.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColsColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     * `df.`[`remove`][org.jetbrains.kotlinx.dataframe.DataFrame.remove]`  {  `[`cols`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]` { it.`[`hasNulls`][org.jetbrains.kotlinx.dataframe.DataColumn.hasNulls]`() } }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myGroupCol.`[`cols`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.cols]`(columnA, columnB) }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[`colsOf`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[`String`][String]`>()`[`[`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.cols]`1, 3, 5`[`]`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.cols]` }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[`select`][DataFrame.select]` { Type::myColumnGroup.`[`cols`][KProperty.cols]`("pathTo"["colA"], "pathTo"["colB"])) }`
+     *
+     * `df.`[`select`][DataFrame.select]` { Type::myColumnGroup.`[`cols`][KProperty.cols]`<`[`String`][String]`>("pathTo"["colA"], "pathTo"["colB"])) }`
+     *
+     * `df.`[`select`][DataFrame.select]` { DataSchemaType::myColumnGroup`[`[`][KProperty.cols]`"columnA", "columnB"`[`]`][KProperty.cols]` }`
+     *
+     *
+     * @param [firstCol] A [ColumnPath] that points to a relative column.
+     * @param [otherCols] Optional additional [ColumnPath]s that point to relative columns.
+     * @throws [IllegalArgumentException] if any of the given [ColumnReference][org.jetbrains.kotlinx.dataframe.columns.ColumnReference]s point to a column that doesn't
+     *   exist.
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing the columns that [firstCol] and [otherCols] point to.
+     */
+    private interface KPropertiesColsVarargColumnPathDocs
+
+    /** ## Cols
+     * Creates a subset of columns ([ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]) from [this].
+     *
+     * You can use either a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter], or any of the `vararg` overloads for any
+     * [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]. The function can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index (range)).
+     *
+     * This function operates solely on columns at the top-level.
+     *
+     * Aside from calling [cols][org.jetbrains.kotlinx.dataframe.api.ColsColumnsSelectionDsl.cols] directly, you can also use the [`get`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.get] operator in most cases.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColsColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     * `df.`[`remove`][org.jetbrains.kotlinx.dataframe.DataFrame.remove]`  {  `[`cols`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]` { it.`[`hasNulls`][org.jetbrains.kotlinx.dataframe.DataColumn.hasNulls]`() } }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myGroupCol.`[`cols`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.cols]`(columnA, columnB) }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[`colsOf`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[`String`][String]`>()`[`[`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.cols]`1, 3, 5`[`]`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.cols]` }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { Type::myColumnGroup.`[`cols`][kotlin.reflect.KProperty.cols]`("pathTo"["colA"], "pathTo"["colB"])) }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { Type::myColumnGroup.`[`cols`][kotlin.reflect.KProperty.cols]`<`[`String`][String]`>("pathTo"["colA"], "pathTo"["colB"])) }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { DataSchemaType::myColumnGroup`[`[`][kotlin.reflect.KProperty.cols]`"columnA", "columnB"`[`]`][kotlin.reflect.KProperty.cols]` }`
+     *
+     *
+     * @param [firstCol] A [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath] that points to a relative column.
+     * @param [otherCols] Optional additional [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath]s that point to relative columns.
+     * @throws [IllegalArgumentException] if any of the given [ColumnReference][org.jetbrains.kotlinx.dataframe.columns.ColumnReference]s point to a column that doesn't
+     *   exist.
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing the columns that [firstCol] and [otherCols] point to.
+     */
+    @Suppress("INAPPLICABLE_JVM_NAME")
+    @JvmName("colsUnTyped")
+    public fun KProperty<*>.cols(firstCol: ColumnPath, vararg otherCols: ColumnPath): ColumnSet<*> =
+        cols<Any?>(firstCol, *otherCols)
+
+    /** ## Cols
+     * Creates a subset of columns ([ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]) from [this].
+     *
+     * You can use either a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter], or any of the `vararg` overloads for any
+     * [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]. The function can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index (range)).
+     *
+     * This function operates solely on columns at the top-level.
+     *
+     * Aside from calling [cols][org.jetbrains.kotlinx.dataframe.api.ColsColumnsSelectionDsl.cols] directly, you can also use the [`get`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.get] operator in most cases.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColsColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     * `df.`[`remove`][org.jetbrains.kotlinx.dataframe.DataFrame.remove]`  {  `[`cols`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]` { it.`[`hasNulls`][org.jetbrains.kotlinx.dataframe.DataColumn.hasNulls]`() } }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myGroupCol.`[`cols`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.cols]`(columnA, columnB) }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[`colsOf`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[`String`][String]`>()`[`[`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.cols]`1, 3, 5`[`]`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.cols]` }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { Type::myColumnGroup.`[`cols`][kotlin.reflect.KProperty.cols]`("pathTo"["colA"], "pathTo"["colB"])) }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { Type::myColumnGroup.`[`cols`][kotlin.reflect.KProperty.cols]`<`[`String`][String]`>("pathTo"["colA"], "pathTo"["colB"])) }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { DataSchemaType::myColumnGroup`[`[`][kotlin.reflect.KProperty.cols]`"columnA", "columnB"`[`]`][kotlin.reflect.KProperty.cols]` }`
+     *
+     *
+     * @param [firstCol] A [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath] that points to a relative column.
+     * @param [otherCols] Optional additional [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath]s that point to relative columns.
+     * @throws [IllegalArgumentException] if any of the given [ColumnReference][org.jetbrains.kotlinx.dataframe.columns.ColumnReference]s point to a column that doesn't
+     *   exist.
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing the columns that [firstCol] and [otherCols] point to.
+     */
+    public fun <T> KProperty<*>.cols(firstCol: ColumnPath, vararg otherCols: ColumnPath): ColumnSet<T> =
+        columnGroup(this).cols(firstCol, *otherCols).cast()
+
+    /** ## Cols
+     * Creates a subset of columns ([ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]) from [this].
+     *
+     * You can use either a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter], or any of the `vararg` overloads for any
+     * [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]. The function can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index (range)).
+     *
+     * This function operates solely on columns at the top-level.
+     *
+     * Aside from calling [cols][org.jetbrains.kotlinx.dataframe.api.ColsColumnsSelectionDsl.cols] directly, you can also use the [`get`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.get] operator in most cases.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColsColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     * `df.`[`remove`][org.jetbrains.kotlinx.dataframe.DataFrame.remove]`  {  `[`cols`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]` { it.`[`hasNulls`][org.jetbrains.kotlinx.dataframe.DataColumn.hasNulls]`() } }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myGroupCol.`[`cols`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.cols]`(columnA, columnB) }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[`colsOf`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[`String`][String]`>()`[`[`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.cols]`1, 3, 5`[`]`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.cols]` }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { Type::myColumnGroup.`[`cols`][kotlin.reflect.KProperty.cols]`("pathTo"["colA"], "pathTo"["colB"])) }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { Type::myColumnGroup.`[`cols`][kotlin.reflect.KProperty.cols]`<`[`String`][String]`>("pathTo"["colA"], "pathTo"["colB"])) }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { DataSchemaType::myColumnGroup`[`[`][kotlin.reflect.KProperty.cols]`"columnA", "columnB"`[`]`][kotlin.reflect.KProperty.cols]` }`
+     *
+     *
+     * @param [firstCol] A [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath] that points to a relative column.
+     * @param [otherCols] Optional additional [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath]s that point to relative columns.
+     * @throws [IllegalArgumentException] if any of the given [ColumnReference][org.jetbrains.kotlinx.dataframe.columns.ColumnReference]s point to a column that doesn't
+     *   exist.
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing the columns that [firstCol] and [otherCols] point to.
+     */
+    public operator fun KProperty<*>.get(firstCol: ColumnPath, vararg otherCols: ColumnPath): ColumnSet<*> =
+        cols<Any?>(firstCol, *otherCols)
+
+    /**
+     * ## Cols
+     * Creates a subset of columns ([ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]) from [this].
+     *
+     * You can use either a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter], or any of the `vararg` overloads for any
+     * [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]. The function can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index (range)).
+     *
+     * This function operates solely on columns at the top-level.
+     *
+     * Aside from calling [cols][org.jetbrains.kotlinx.dataframe.api.ColsColumnsSelectionDsl.cols] directly, you can also use the [`get`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.get] operator in most cases.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColsColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     * `df.`[`remove`][org.jetbrains.kotlinx.dataframe.DataFrame.remove]`  {  `[`cols`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]` { it.`[`hasNulls`][org.jetbrains.kotlinx.dataframe.DataColumn.hasNulls]`() } }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myGroupCol.`[`cols`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.cols]`(columnA, columnB) }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[`colsOf`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[`String`][String]`>()`[`[`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.cols]`1, 3, 5`[`]`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.cols]` }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[`select`][DataFrame.select]` { "pathTo"["columnGroup"].`[`cols`][ColumnPath.cols]`("pathTo"["colA"], "pathTo"["colB"])) }`
+     *
+     * `df.`[`select`][DataFrame.select]` { "pathTo"["columnGroup"].`[`cols`][ColumnPath.cols]`<`[`String`][String]`>("pathTo"["colA"], "pathTo"["colB"])) }`
+     *
+     * `df.`[`select`][DataFrame.select]` { "pathTo"["columnGroup"]`[`[`][ColumnPath.cols]`"pathTo"["colA"], "pathTo"["colB"])`[`]`][ColumnPath.cols]` }`
+     *
+     *
+     * @param [firstCol] A [ColumnPath] that points to a relative column.
+     * @param [otherCols] Optional additional [ColumnPath]s that point to relative columns.
+     * @throws [IllegalArgumentException] if any of the given [ColumnReference][org.jetbrains.kotlinx.dataframe.columns.ColumnReference]s point to a column that doesn't
+     *   exist.
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing the columns that [firstCol] and [otherCols] point to.
+     */
+    private interface ColumnPathColsVarargColumnPathDocs
+
+    /** ## Cols
+     * Creates a subset of columns ([ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]) from [this].
+     *
+     * You can use either a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter], or any of the `vararg` overloads for any
+     * [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]. The function can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index (range)).
+     *
+     * This function operates solely on columns at the top-level.
+     *
+     * Aside from calling [cols][org.jetbrains.kotlinx.dataframe.api.ColsColumnsSelectionDsl.cols] directly, you can also use the [`get`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.get] operator in most cases.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColsColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     * `df.`[`remove`][org.jetbrains.kotlinx.dataframe.DataFrame.remove]`  {  `[`cols`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]` { it.`[`hasNulls`][org.jetbrains.kotlinx.dataframe.DataColumn.hasNulls]`() } }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myGroupCol.`[`cols`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.cols]`(columnA, columnB) }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[`colsOf`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[`String`][String]`>()`[`[`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.cols]`1, 3, 5`[`]`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.cols]` }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "pathTo"["columnGroup"].`[`cols`][org.jetbrains.kotlinx.dataframe.columns.ColumnPath.cols]`("pathTo"["colA"], "pathTo"["colB"])) }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "pathTo"["columnGroup"].`[`cols`][org.jetbrains.kotlinx.dataframe.columns.ColumnPath.cols]`<`[`String`][String]`>("pathTo"["colA"], "pathTo"["colB"])) }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "pathTo"["columnGroup"]`[`[`][org.jetbrains.kotlinx.dataframe.columns.ColumnPath.cols]`"pathTo"["colA"], "pathTo"["colB"])`[`]`][org.jetbrains.kotlinx.dataframe.columns.ColumnPath.cols]` }`
+     *
+     *
+     * @param [firstCol] A [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath] that points to a relative column.
+     * @param [otherCols] Optional additional [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath]s that point to relative columns.
+     * @throws [IllegalArgumentException] if any of the given [ColumnReference][org.jetbrains.kotlinx.dataframe.columns.ColumnReference]s point to a column that doesn't
+     *   exist.
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing the columns that [firstCol] and [otherCols] point to.
+     */
+    @Suppress("INAPPLICABLE_JVM_NAME")
+    @JvmName("colsUnTyped")
+    public fun ColumnPath.cols(firstCol: ColumnPath, vararg otherCols: ColumnPath): ColumnSet<*> =
+        cols<Any?>(firstCol, *otherCols)
+
+    /** ## Cols
+     * Creates a subset of columns ([ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]) from [this].
+     *
+     * You can use either a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter], or any of the `vararg` overloads for any
+     * [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]. The function can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index (range)).
+     *
+     * This function operates solely on columns at the top-level.
+     *
+     * Aside from calling [cols][org.jetbrains.kotlinx.dataframe.api.ColsColumnsSelectionDsl.cols] directly, you can also use the [`get`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.get] operator in most cases.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColsColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     * `df.`[`remove`][org.jetbrains.kotlinx.dataframe.DataFrame.remove]`  {  `[`cols`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]` { it.`[`hasNulls`][org.jetbrains.kotlinx.dataframe.DataColumn.hasNulls]`() } }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myGroupCol.`[`cols`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.cols]`(columnA, columnB) }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[`colsOf`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[`String`][String]`>()`[`[`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.cols]`1, 3, 5`[`]`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.cols]` }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "pathTo"["columnGroup"].`[`cols`][org.jetbrains.kotlinx.dataframe.columns.ColumnPath.cols]`("pathTo"["colA"], "pathTo"["colB"])) }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "pathTo"["columnGroup"].`[`cols`][org.jetbrains.kotlinx.dataframe.columns.ColumnPath.cols]`<`[`String`][String]`>("pathTo"["colA"], "pathTo"["colB"])) }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "pathTo"["columnGroup"]`[`[`][org.jetbrains.kotlinx.dataframe.columns.ColumnPath.cols]`"pathTo"["colA"], "pathTo"["colB"])`[`]`][org.jetbrains.kotlinx.dataframe.columns.ColumnPath.cols]` }`
+     *
+     *
+     * @param [firstCol] A [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath] that points to a relative column.
+     * @param [otherCols] Optional additional [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath]s that point to relative columns.
+     * @throws [IllegalArgumentException] if any of the given [ColumnReference][org.jetbrains.kotlinx.dataframe.columns.ColumnReference]s point to a column that doesn't
+     *   exist.
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing the columns that [firstCol] and [otherCols] point to.
+     */
+    public fun <T> ColumnPath.cols(firstCol: ColumnPath, vararg otherCols: ColumnPath): ColumnSet<T> =
+        columnGroup(this).cols(firstCol, *otherCols).cast()
+
+    /** ## Cols
+     * Creates a subset of columns ([ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]) from [this].
+     *
+     * You can use either a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter], or any of the `vararg` overloads for any
+     * [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]. The function can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index (range)).
+     *
+     * This function operates solely on columns at the top-level.
+     *
+     * Aside from calling [cols][org.jetbrains.kotlinx.dataframe.api.ColsColumnsSelectionDsl.cols] directly, you can also use the [`get`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.get] operator in most cases.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColsColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     * `df.`[`remove`][org.jetbrains.kotlinx.dataframe.DataFrame.remove]`  {  `[`cols`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]` { it.`[`hasNulls`][org.jetbrains.kotlinx.dataframe.DataColumn.hasNulls]`() } }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myGroupCol.`[`cols`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.cols]`(columnA, columnB) }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[`colsOf`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[`String`][String]`>()`[`[`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.cols]`1, 3, 5`[`]`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.cols]` }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "pathTo"["columnGroup"].`[`cols`][org.jetbrains.kotlinx.dataframe.columns.ColumnPath.cols]`("pathTo"["colA"], "pathTo"["colB"])) }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "pathTo"["columnGroup"].`[`cols`][org.jetbrains.kotlinx.dataframe.columns.ColumnPath.cols]`<`[`String`][String]`>("pathTo"["colA"], "pathTo"["colB"])) }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "pathTo"["columnGroup"]`[`[`][org.jetbrains.kotlinx.dataframe.columns.ColumnPath.cols]`"pathTo"["colA"], "pathTo"["colB"])`[`]`][org.jetbrains.kotlinx.dataframe.columns.ColumnPath.cols]` }`
+     *
+     *
+     * @param [firstCol] A [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath] that points to a relative column.
+     * @param [otherCols] Optional additional [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath]s that point to relative columns.
+     * @throws [IllegalArgumentException] if any of the given [ColumnReference][org.jetbrains.kotlinx.dataframe.columns.ColumnReference]s point to a column that doesn't
+     *   exist.
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing the columns that [firstCol] and [otherCols] point to.
+     */
+    public operator fun ColumnPath.get(firstCol: ColumnPath, vararg otherCols: ColumnPath): ColumnSet<*> =
+        cols<Any?>(firstCol, *otherCols)
+
+    // endregion
+
+    // region properties
+
+    /**
+     * ## Cols
+     * Creates a subset of columns ([ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]) from [this].
+     *
+     * You can use either a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter], or any of the `vararg` overloads for any
+     * [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]. The function can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index (range)).
+     *
+     * This function operates solely on columns at the top-level.
+     *
+     * Aside from calling [cols][org.jetbrains.kotlinx.dataframe.api.ColsColumnsSelectionDsl.cols] directly, you can also use the [`get`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.get] operator in most cases.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColsColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     * `df.`[`remove`][org.jetbrains.kotlinx.dataframe.DataFrame.remove]`  {  `[`cols`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]` { it.`[`hasNulls`][org.jetbrains.kotlinx.dataframe.DataColumn.hasNulls]`() } }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myGroupCol.`[`cols`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.cols]`(columnA, columnB) }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[`colsOf`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[`String`][String]`>()`[`[`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.cols]`1, 3, 5`[`]`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.cols]` }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[`select`][DataFrame.select]`  {  `[`cols`][ColumnsSelectionDsl.cols]`(Type::colA, Type::colB) }`
+     *
+     * `df.`[`select`][DataFrame.select]` { this`[`[`][ColumnsSelectionDsl.cols]`Type::colA, Type::colB`[`]`][ColumnsSelectionDsl.cols]` }`
+     *
+     *
+     * @param [firstCol] A [KProperty] that points to a relative column.
+     * @param [otherCols] Optional additional [KProperty]s that point to relative columns.
+     * @throws [IllegalArgumentException] if any of the given [ColumnReference][org.jetbrains.kotlinx.dataframe.columns.ColumnReference]s point to a column that doesn't
+     *   exist.
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing the columns that [firstCol] and [otherCols] point to.
+     */
+    private interface ColumnsSelectionDslColsVarargKPropertyDocs
+
+    /** ## Cols
+     * Creates a subset of columns ([ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]) from [this].
+     *
+     * You can use either a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter], or any of the `vararg` overloads for any
+     * [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]. The function can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index (range)).
+     *
+     * This function operates solely on columns at the top-level.
+     *
+     * Aside from calling [cols][org.jetbrains.kotlinx.dataframe.api.ColsColumnsSelectionDsl.cols] directly, you can also use the [`get`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.get] operator in most cases.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColsColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     * `df.`[`remove`][org.jetbrains.kotlinx.dataframe.DataFrame.remove]`  {  `[`cols`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]` { it.`[`hasNulls`][org.jetbrains.kotlinx.dataframe.DataColumn.hasNulls]`() } }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myGroupCol.`[`cols`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.cols]`(columnA, columnB) }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[`colsOf`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[`String`][String]`>()`[`[`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.cols]`1, 3, 5`[`]`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.cols]` }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[`cols`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`(Type::colA, Type::colB) }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { this`[`[`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`Type::colA, Type::colB`[`]`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]` }`
+     *
+     *
+     * @param [firstCol] A [KProperty] that points to a relative column.
+     * @param [otherCols] Optional additional [KProperty]s that point to relative columns.
+     * @throws [IllegalArgumentException] if any of the given [ColumnReference][org.jetbrains.kotlinx.dataframe.columns.ColumnReference]s point to a column that doesn't
+     *   exist.
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing the columns that [firstCol] and [otherCols] point to.
+     */
+    public fun <C> ColumnsSelectionDsl<*>.cols(firstCol: KProperty<C>, vararg otherCols: KProperty<C>): ColumnSet<C> =
+        this.asSingleColumn().cols(firstCol, *otherCols)
+
+    /** ## Cols
+     * Creates a subset of columns ([ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]) from [this].
+     *
+     * You can use either a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter], or any of the `vararg` overloads for any
+     * [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]. The function can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index (range)).
+     *
+     * This function operates solely on columns at the top-level.
+     *
+     * Aside from calling [cols][org.jetbrains.kotlinx.dataframe.api.ColsColumnsSelectionDsl.cols] directly, you can also use the [`get`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.get] operator in most cases.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColsColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     * `df.`[`remove`][org.jetbrains.kotlinx.dataframe.DataFrame.remove]`  {  `[`cols`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]` { it.`[`hasNulls`][org.jetbrains.kotlinx.dataframe.DataColumn.hasNulls]`() } }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myGroupCol.`[`cols`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.cols]`(columnA, columnB) }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[`colsOf`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[`String`][String]`>()`[`[`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.cols]`1, 3, 5`[`]`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.cols]` }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[`cols`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`(Type::colA, Type::colB) }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { this`[`[`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`Type::colA, Type::colB`[`]`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]` }`
+     *
+     *
+     * @param [firstCol] A [KProperty] that points to a relative column.
+     * @param [otherCols] Optional additional [KProperty]s that point to relative columns.
+     * @throws [IllegalArgumentException] if any of the given [ColumnReference][org.jetbrains.kotlinx.dataframe.columns.ColumnReference]s point to a column that doesn't
+     *   exist.
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing the columns that [firstCol] and [otherCols] point to.
+     */
+    public operator fun <C> ColumnsSelectionDsl<*>.get(
+        firstCol: KProperty<C>,
+        vararg otherCols: KProperty<C>,
+    ): ColumnSet<C> = cols(firstCol, *otherCols)
+
+    /**
+     * ## Cols
+     * Creates a subset of columns ([ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]) from [this].
+     *
+     * You can use either a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter], or any of the `vararg` overloads for any
+     * [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]. The function can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index (range)).
+     *
+     * This function operates solely on columns at the top-level.
+     *
+     * Aside from calling [cols][org.jetbrains.kotlinx.dataframe.api.ColsColumnsSelectionDsl.cols] directly, you can also use the [`get`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.get] operator in most cases.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColsColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     * `df.`[`remove`][org.jetbrains.kotlinx.dataframe.DataFrame.remove]`  {  `[`cols`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]` { it.`[`hasNulls`][org.jetbrains.kotlinx.dataframe.DataColumn.hasNulls]`() } }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myGroupCol.`[`cols`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.cols]`(columnA, columnB) }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[`colsOf`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[`String`][String]`>()`[`[`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.cols]`1, 3, 5`[`]`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.cols]` }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[`select`][DataFrame.select]` { myColumnGroup.`[`cols`][SingleColumn.cols]`(Type::colA, Type::colB) }`
+     *
+     * `df.`[`select`][DataFrame.select]` { myColumnGroup`[`[`][SingleColumn.cols]`Type::colA, Type::colB`[`]`][SingleColumn.cols]` }`
+     *
+     *
+     * @param [firstCol] A [KProperty] that points to a relative column.
+     * @param [otherCols] Optional additional [KProperty]s that point to relative columns.
+     * @throws [IllegalArgumentException] if any of the given [ColumnReference][org.jetbrains.kotlinx.dataframe.columns.ColumnReference]s point to a column that doesn't
+     *   exist.
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing the columns that [firstCol] and [otherCols] point to.
+     */
+    private interface SingleColumnColsVarargKPropertyDocs
+
+    /** ## Cols
+     * Creates a subset of columns ([ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]) from [this].
+     *
+     * You can use either a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter], or any of the `vararg` overloads for any
+     * [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]. The function can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index (range)).
+     *
+     * This function operates solely on columns at the top-level.
+     *
+     * Aside from calling [cols][org.jetbrains.kotlinx.dataframe.api.ColsColumnsSelectionDsl.cols] directly, you can also use the [`get`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.get] operator in most cases.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColsColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     * `df.`[`remove`][org.jetbrains.kotlinx.dataframe.DataFrame.remove]`  {  `[`cols`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]` { it.`[`hasNulls`][org.jetbrains.kotlinx.dataframe.DataColumn.hasNulls]`() } }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myGroupCol.`[`cols`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.cols]`(columnA, columnB) }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[`colsOf`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[`String`][String]`>()`[`[`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.cols]`1, 3, 5`[`]`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.cols]` }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[`cols`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.cols]`(Type::colA, Type::colB) }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup`[`[`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.cols]`Type::colA, Type::colB`[`]`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.cols]` }`
+     *
+     *
+     * @param [firstCol] A [KProperty] that points to a relative column.
+     * @param [otherCols] Optional additional [KProperty]s that point to relative columns.
+     * @throws [IllegalArgumentException] if any of the given [ColumnReference][org.jetbrains.kotlinx.dataframe.columns.ColumnReference]s point to a column that doesn't
+     *   exist.
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing the columns that [firstCol] and [otherCols] point to.
+     */
+    public fun <C> SingleColumn<DataRow<*>>.cols(
+        firstCol: KProperty<C>,
+        vararg otherCols: KProperty<C>,
+    ): ColumnSet<C> = colsInternal(listOf(firstCol, *otherCols).map { pathOf(it.name) }).cast()
+
+    /** ## Cols
+     * Creates a subset of columns ([ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]) from [this].
+     *
+     * You can use either a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter], or any of the `vararg` overloads for any
+     * [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]. The function can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index (range)).
+     *
+     * This function operates solely on columns at the top-level.
+     *
+     * Aside from calling [cols][org.jetbrains.kotlinx.dataframe.api.ColsColumnsSelectionDsl.cols] directly, you can also use the [`get`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.get] operator in most cases.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColsColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     * `df.`[`remove`][org.jetbrains.kotlinx.dataframe.DataFrame.remove]`  {  `[`cols`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]` { it.`[`hasNulls`][org.jetbrains.kotlinx.dataframe.DataColumn.hasNulls]`() } }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myGroupCol.`[`cols`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.cols]`(columnA, columnB) }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[`colsOf`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[`String`][String]`>()`[`[`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.cols]`1, 3, 5`[`]`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.cols]` }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[`cols`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.cols]`(Type::colA, Type::colB) }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup`[`[`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.cols]`Type::colA, Type::colB`[`]`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.cols]` }`
+     *
+     *
+     * @param [firstCol] A [KProperty] that points to a relative column.
+     * @param [otherCols] Optional additional [KProperty]s that point to relative columns.
+     * @throws [IllegalArgumentException] if any of the given [ColumnReference][org.jetbrains.kotlinx.dataframe.columns.ColumnReference]s point to a column that doesn't
+     *   exist.
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing the columns that [firstCol] and [otherCols] point to.
+     */
+    public operator fun <C> SingleColumn<DataRow<*>>.get(
+        firstCol: KProperty<C>,
+        vararg otherCols: KProperty<C>,
+    ): ColumnSet<C> = cols(firstCol, *otherCols)
+
+    /**
+     * ## Cols
+     * Creates a subset of columns ([ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]) from [this].
+     *
+     * You can use either a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter], or any of the `vararg` overloads for any
+     * [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]. The function can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index (range)).
+     *
+     * This function operates solely on columns at the top-level.
+     *
+     * Aside from calling [cols][org.jetbrains.kotlinx.dataframe.api.ColsColumnsSelectionDsl.cols] directly, you can also use the [`get`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.get] operator in most cases.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColsColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     * `df.`[`remove`][org.jetbrains.kotlinx.dataframe.DataFrame.remove]`  {  `[`cols`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]` { it.`[`hasNulls`][org.jetbrains.kotlinx.dataframe.DataColumn.hasNulls]`() } }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myGroupCol.`[`cols`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.cols]`(columnA, columnB) }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[`colsOf`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[`String`][String]`>()`[`[`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.cols]`1, 3, 5`[`]`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.cols]` }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[`select`][DataFrame.select]` { "myColumnGroup".`[`cols`][String.cols]`(Type::colA, Type::colB) }`
+     *
+     * `df.`[`select`][DataFrame.select]` { "myColumnGroup"`[`[`][String.cols]`Type::colA, Type::colB`[`]`][String.cols]` }`
+     *
+     *
+     * @param [firstCol] A [KProperty] that points to a relative column.
+     * @param [otherCols] Optional additional [KProperty]s that point to relative columns.
+     * @throws [IllegalArgumentException] if any of the given [ColumnReference][org.jetbrains.kotlinx.dataframe.columns.ColumnReference]s point to a column that doesn't
+     *   exist.
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing the columns that [firstCol] and [otherCols] point to.
+     */
+    private interface StringColsVarargKPropertyDocs
+
+    /** ## Cols
+     * Creates a subset of columns ([ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]) from [this].
+     *
+     * You can use either a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter], or any of the `vararg` overloads for any
+     * [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]. The function can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index (range)).
+     *
+     * This function operates solely on columns at the top-level.
+     *
+     * Aside from calling [cols][org.jetbrains.kotlinx.dataframe.api.ColsColumnsSelectionDsl.cols] directly, you can also use the [`get`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.get] operator in most cases.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColsColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     * `df.`[`remove`][org.jetbrains.kotlinx.dataframe.DataFrame.remove]`  {  `[`cols`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]` { it.`[`hasNulls`][org.jetbrains.kotlinx.dataframe.DataColumn.hasNulls]`() } }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myGroupCol.`[`cols`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.cols]`(columnA, columnB) }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[`colsOf`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[`String`][String]`>()`[`[`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.cols]`1, 3, 5`[`]`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.cols]` }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "myColumnGroup".`[`cols`][kotlin.String.cols]`(Type::colA, Type::colB) }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "myColumnGroup"`[`[`][kotlin.String.cols]`Type::colA, Type::colB`[`]`][kotlin.String.cols]` }`
+     *
+     *
+     * @param [firstCol] A [KProperty] that points to a relative column.
+     * @param [otherCols] Optional additional [KProperty]s that point to relative columns.
+     * @throws [IllegalArgumentException] if any of the given [ColumnReference][org.jetbrains.kotlinx.dataframe.columns.ColumnReference]s point to a column that doesn't
+     *   exist.
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing the columns that [firstCol] and [otherCols] point to.
+     */
+    public fun <C> String.cols(firstCol: KProperty<C>, vararg otherCols: KProperty<C>): ColumnSet<C> =
+        columnGroup(this).cols(firstCol, *otherCols)
+
+    /** ## Cols
+     * Creates a subset of columns ([ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]) from [this].
+     *
+     * You can use either a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter], or any of the `vararg` overloads for any
+     * [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]. The function can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index (range)).
+     *
+     * This function operates solely on columns at the top-level.
+     *
+     * Aside from calling [cols][org.jetbrains.kotlinx.dataframe.api.ColsColumnsSelectionDsl.cols] directly, you can also use the [`get`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.get] operator in most cases.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColsColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     * `df.`[`remove`][org.jetbrains.kotlinx.dataframe.DataFrame.remove]`  {  `[`cols`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]` { it.`[`hasNulls`][org.jetbrains.kotlinx.dataframe.DataColumn.hasNulls]`() } }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myGroupCol.`[`cols`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.cols]`(columnA, columnB) }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[`colsOf`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[`String`][String]`>()`[`[`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.cols]`1, 3, 5`[`]`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.cols]` }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "myColumnGroup".`[`cols`][kotlin.String.cols]`(Type::colA, Type::colB) }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "myColumnGroup"`[`[`][kotlin.String.cols]`Type::colA, Type::colB`[`]`][kotlin.String.cols]` }`
+     *
+     *
+     * @param [firstCol] A [KProperty] that points to a relative column.
+     * @param [otherCols] Optional additional [KProperty]s that point to relative columns.
+     * @throws [IllegalArgumentException] if any of the given [ColumnReference][org.jetbrains.kotlinx.dataframe.columns.ColumnReference]s point to a column that doesn't
+     *   exist.
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing the columns that [firstCol] and [otherCols] point to.
+     */
+    public operator fun <C> String.get(firstCol: KProperty<C>, vararg otherCols: KProperty<C>): ColumnSet<C> =
+        cols(firstCol, *otherCols)
+
+    /**
+     * ## Cols
+     * Creates a subset of columns ([ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]) from [this].
+     *
+     * You can use either a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter], or any of the `vararg` overloads for any
+     * [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]. The function can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index (range)).
+     *
+     * This function operates solely on columns at the top-level.
+     *
+     * Aside from calling [cols][org.jetbrains.kotlinx.dataframe.api.ColsColumnsSelectionDsl.cols] directly, you can also use the [`get`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.get] operator in most cases.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColsColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     * `df.`[`remove`][org.jetbrains.kotlinx.dataframe.DataFrame.remove]`  {  `[`cols`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]` { it.`[`hasNulls`][org.jetbrains.kotlinx.dataframe.DataColumn.hasNulls]`() } }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myGroupCol.`[`cols`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.cols]`(columnA, columnB) }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[`colsOf`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[`String`][String]`>()`[`[`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.cols]`1, 3, 5`[`]`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.cols]` }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[`select`][DataFrame.select]` { Type::myColumnGroup.`[`cols`][SingleColumn.cols]`(Type::colA, Type::colB) }`
+     *
+     * `df.`[`select`][DataFrame.select]` { Type::myColumnGroup`[`[`][SingleColumn.cols]`Type::colA, Type::colB`[`]`][SingleColumn.cols]` }`
+     *
+     *
+     * @param [firstCol] A [KProperty] that points to a relative column.
+     * @param [otherCols] Optional additional [KProperty]s that point to relative columns.
+     * @throws [IllegalArgumentException] if any of the given [ColumnReference][org.jetbrains.kotlinx.dataframe.columns.ColumnReference]s point to a column that doesn't
+     *   exist.
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing the columns that [firstCol] and [otherCols] point to.
+     */
+    private interface KPropertyColsVarargKPropertyDocs
+
+    /** ## Cols
+     * Creates a subset of columns ([ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]) from [this].
+     *
+     * You can use either a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter], or any of the `vararg` overloads for any
+     * [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]. The function can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index (range)).
+     *
+     * This function operates solely on columns at the top-level.
+     *
+     * Aside from calling [cols][org.jetbrains.kotlinx.dataframe.api.ColsColumnsSelectionDsl.cols] directly, you can also use the [`get`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.get] operator in most cases.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColsColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     * `df.`[`remove`][org.jetbrains.kotlinx.dataframe.DataFrame.remove]`  {  `[`cols`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]` { it.`[`hasNulls`][org.jetbrains.kotlinx.dataframe.DataColumn.hasNulls]`() } }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myGroupCol.`[`cols`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.cols]`(columnA, columnB) }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[`colsOf`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[`String`][String]`>()`[`[`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.cols]`1, 3, 5`[`]`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.cols]` }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { Type::myColumnGroup.`[`cols`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.cols]`(Type::colA, Type::colB) }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { Type::myColumnGroup`[`[`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.cols]`Type::colA, Type::colB`[`]`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.cols]` }`
+     *
+     *
+     * @param [firstCol] A [KProperty] that points to a relative column.
+     * @param [otherCols] Optional additional [KProperty]s that point to relative columns.
+     * @throws [IllegalArgumentException] if any of the given [ColumnReference][org.jetbrains.kotlinx.dataframe.columns.ColumnReference]s point to a column that doesn't
+     *   exist.
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing the columns that [firstCol] and [otherCols] point to.
+     */
+    public fun <C> KProperty<*>.cols(firstCol: KProperty<C>, vararg otherCols: KProperty<C>): ColumnSet<C> =
+        columnGroup(this).cols(firstCol, *otherCols)
+
+    /** ## Cols
+     * Creates a subset of columns ([ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]) from [this].
+     *
+     * You can use either a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter], or any of the `vararg` overloads for any
+     * [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]. The function can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index (range)).
+     *
+     * This function operates solely on columns at the top-level.
+     *
+     * Aside from calling [cols][org.jetbrains.kotlinx.dataframe.api.ColsColumnsSelectionDsl.cols] directly, you can also use the [`get`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.get] operator in most cases.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColsColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     * `df.`[`remove`][org.jetbrains.kotlinx.dataframe.DataFrame.remove]`  {  `[`cols`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]` { it.`[`hasNulls`][org.jetbrains.kotlinx.dataframe.DataColumn.hasNulls]`() } }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myGroupCol.`[`cols`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.cols]`(columnA, columnB) }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[`colsOf`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[`String`][String]`>()`[`[`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.cols]`1, 3, 5`[`]`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.cols]` }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { Type::myColumnGroup.`[`cols`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.cols]`(Type::colA, Type::colB) }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { Type::myColumnGroup`[`[`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.cols]`Type::colA, Type::colB`[`]`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.cols]` }`
+     *
+     *
+     * @param [firstCol] A [KProperty] that points to a relative column.
+     * @param [otherCols] Optional additional [KProperty]s that point to relative columns.
+     * @throws [IllegalArgumentException] if any of the given [ColumnReference][org.jetbrains.kotlinx.dataframe.columns.ColumnReference]s point to a column that doesn't
+     *   exist.
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing the columns that [firstCol] and [otherCols] point to.
+     */
+    public operator fun <C> KProperty<*>.get(firstCol: KProperty<C>, vararg otherCols: KProperty<C>): ColumnSet<C> =
+        cols(firstCol, *otherCols)
+
+    /**
+     * ## Cols
+     * Creates a subset of columns ([ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]) from [this].
+     *
+     * You can use either a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter], or any of the `vararg` overloads for any
+     * [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]. The function can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index (range)).
+     *
+     * This function operates solely on columns at the top-level.
+     *
+     * Aside from calling [cols][org.jetbrains.kotlinx.dataframe.api.ColsColumnsSelectionDsl.cols] directly, you can also use the [`get`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.get] operator in most cases.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColsColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     * `df.`[`remove`][org.jetbrains.kotlinx.dataframe.DataFrame.remove]`  {  `[`cols`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]` { it.`[`hasNulls`][org.jetbrains.kotlinx.dataframe.DataColumn.hasNulls]`() } }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myGroupCol.`[`cols`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.cols]`(columnA, columnB) }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[`colsOf`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[`String`][String]`>()`[`[`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.cols]`1, 3, 5`[`]`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.cols]` }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[`select`][DataFrame.select]` { "pathTo"["columnGroup"].`[`cols`][ColumnPath.cols]`(Type::colA, Type::colB) }`
+     *
+     * `df.`[`select`][DataFrame.select]` { "pathTo"["columnGroup"]`[`[`][ColumnPath.cols]`Type::colA, Type::colB`[`]`][ColumnPath.cols]` }`
+     *
+     *
+     * @param [firstCol] A [KProperty] that points to a relative column.
+     * @param [otherCols] Optional additional [KProperty]s that point to relative columns.
+     * @throws [IllegalArgumentException] if any of the given [ColumnReference][org.jetbrains.kotlinx.dataframe.columns.ColumnReference]s point to a column that doesn't
+     *   exist.
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing the columns that [firstCol] and [otherCols] point to.
+     */
+    private interface ColumnPathColsVarargKPropertyDocs
+
+    /** ## Cols
+     * Creates a subset of columns ([ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]) from [this].
+     *
+     * You can use either a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter], or any of the `vararg` overloads for any
+     * [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]. The function can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index (range)).
+     *
+     * This function operates solely on columns at the top-level.
+     *
+     * Aside from calling [cols][org.jetbrains.kotlinx.dataframe.api.ColsColumnsSelectionDsl.cols] directly, you can also use the [`get`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.get] operator in most cases.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColsColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     * `df.`[`remove`][org.jetbrains.kotlinx.dataframe.DataFrame.remove]`  {  `[`cols`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]` { it.`[`hasNulls`][org.jetbrains.kotlinx.dataframe.DataColumn.hasNulls]`() } }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myGroupCol.`[`cols`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.cols]`(columnA, columnB) }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[`colsOf`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[`String`][String]`>()`[`[`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.cols]`1, 3, 5`[`]`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.cols]` }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "pathTo"["columnGroup"].`[`cols`][org.jetbrains.kotlinx.dataframe.columns.ColumnPath.cols]`(Type::colA, Type::colB) }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "pathTo"["columnGroup"]`[`[`][org.jetbrains.kotlinx.dataframe.columns.ColumnPath.cols]`Type::colA, Type::colB`[`]`][org.jetbrains.kotlinx.dataframe.columns.ColumnPath.cols]` }`
+     *
+     *
+     * @param [firstCol] A [KProperty] that points to a relative column.
+     * @param [otherCols] Optional additional [KProperty]s that point to relative columns.
+     * @throws [IllegalArgumentException] if any of the given [ColumnReference][org.jetbrains.kotlinx.dataframe.columns.ColumnReference]s point to a column that doesn't
+     *   exist.
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing the columns that [firstCol] and [otherCols] point to.
+     */
+    public fun <C> ColumnPath.cols(firstCol: KProperty<C>, vararg otherCols: KProperty<C>): ColumnSet<C> =
+        columnGroup(this).cols(firstCol, *otherCols)
+
+    /** ## Cols
+     * Creates a subset of columns ([ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]) from [this].
+     *
+     * You can use either a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter], or any of the `vararg` overloads for any
+     * [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]. The function can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index (range)).
+     *
+     * This function operates solely on columns at the top-level.
+     *
+     * Aside from calling [cols][org.jetbrains.kotlinx.dataframe.api.ColsColumnsSelectionDsl.cols] directly, you can also use the [`get`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.get] operator in most cases.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColsColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     * `df.`[`remove`][org.jetbrains.kotlinx.dataframe.DataFrame.remove]`  {  `[`cols`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]` { it.`[`hasNulls`][org.jetbrains.kotlinx.dataframe.DataColumn.hasNulls]`() } }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myGroupCol.`[`cols`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.cols]`(columnA, columnB) }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[`colsOf`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[`String`][String]`>()`[`[`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.cols]`1, 3, 5`[`]`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.cols]` }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "pathTo"["columnGroup"].`[`cols`][org.jetbrains.kotlinx.dataframe.columns.ColumnPath.cols]`(Type::colA, Type::colB) }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "pathTo"["columnGroup"]`[`[`][org.jetbrains.kotlinx.dataframe.columns.ColumnPath.cols]`Type::colA, Type::colB`[`]`][org.jetbrains.kotlinx.dataframe.columns.ColumnPath.cols]` }`
+     *
+     *
+     * @param [firstCol] A [KProperty] that points to a relative column.
+     * @param [otherCols] Optional additional [KProperty]s that point to relative columns.
+     * @throws [IllegalArgumentException] if any of the given [ColumnReference][org.jetbrains.kotlinx.dataframe.columns.ColumnReference]s point to a column that doesn't
+     *   exist.
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing the columns that [firstCol] and [otherCols] point to.
+     */
+    public operator fun <C> ColumnPath.get(firstCol: KProperty<C>, vararg otherCols: KProperty<C>): ColumnSet<C> =
+        cols(firstCol, *otherCols)
+
+    // endregion
+
+    // region indices
+
+    /**
+     * ## Cols: Columns by Indices
+     *
+     * Retrieves one or multiple columns from [this] in the form of a [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] by their indices.
+     * If any of the indices are out of bounds, an [IndexOutOfBoundsException] is thrown.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColsColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[`cols`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.cols]`(1, 3, 2) }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[`colsOf`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[`Int`][Int]`>()`[`[`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.get]`5, 1, 2`[`]`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.get]` }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "myColumnGroup".`[`cols`][kotlin.String.cols]`(0, 2) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[`select`][DataFrame.select]`  {  `[`colsOf`][SingleColumn.colsOf]`<`[`Int`][Int]`>().`[`cols`][ColumnSet.cols]`(1, 3) }`
+     *
+     * `df.`[`select`][DataFrame.select]`  {  `[`all`][ColumnsSelectionDsl.all]`()`[`[`][ColumnSet.cols]`5, 1`[`]`][ColumnSet.cols]` }`
+     *
+     * @throws [IndexOutOfBoundsException] If any index is out of bounds.
+     * @param [firstIndex] The index of the first column to retrieve.
+     * @param [otherIndices] The other indices of the columns to retrieve.
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing the columns found at the given indices.
+     */
+    private interface ColumnSetColsIndicesDocs
+
+    /** ## Cols: Columns by Indices
+     *
+     * Retrieves one or multiple columns from [this] in the form of a [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] by their indices.
+     * If any of the indices are out of bounds, an [IndexOutOfBoundsException] is thrown.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColsColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[`cols`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.cols]`(1, 3, 2) }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[`colsOf`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[`Int`][Int]`>()`[`[`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.get]`5, 1, 2`[`]`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.get]` }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "myColumnGroup".`[`cols`][kotlin.String.cols]`(0, 2) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[`colsOf`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.colsOf]`<`[`Int`][Int]`>().`[`cols`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.cols]`(1, 3) }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[`all`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.all]`()`[`[`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.cols]`5, 1`[`]`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.cols]` }`
+     *
+     * @throws [IndexOutOfBoundsException] If any index is out of bounds.
+     * @param [firstIndex] The index of the first column to retrieve.
+     * @param [otherIndices] The other indices of the columns to retrieve.
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing the columns found at the given indices.
+     */
+    @Suppress("UNCHECKED_CAST")
+    public fun <C> ColumnSet<C>.cols(firstIndex: Int, vararg otherIndices: Int): ColumnSet<C> =
+        colsInternal(headPlusArray(firstIndex, otherIndices)) as ColumnSet<C>
+
+    /** ## Cols: Columns by Indices
+     *
+     * Retrieves one or multiple columns from [this] in the form of a [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] by their indices.
+     * If any of the indices are out of bounds, an [IndexOutOfBoundsException] is thrown.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColsColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[`cols`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.cols]`(1, 3, 2) }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[`colsOf`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[`Int`][Int]`>()`[`[`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.get]`5, 1, 2`[`]`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.get]` }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "myColumnGroup".`[`cols`][kotlin.String.cols]`(0, 2) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[`colsOf`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.colsOf]`<`[`Int`][Int]`>().`[`cols`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.cols]`(1, 3) }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[`all`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.all]`()`[`[`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.cols]`5, 1`[`]`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.cols]` }`
+     *
+     * @throws [IndexOutOfBoundsException] If any index is out of bounds.
+     * @param [firstIndex] The index of the first column to retrieve.
+     * @param [otherIndices] The other indices of the columns to retrieve.
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing the columns found at the given indices.
+     */
+    public operator fun <C> ColumnSet<C>.get(firstIndex: Int, vararg otherIndices: Int): ColumnSet<C> =
+        cols(firstIndex, *otherIndices)
+
+    /**
+     * ## Cols: Columns by Indices
+     *
+     * Retrieves one or multiple columns from [this] in the form of a [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] by their indices.
+     * If any of the indices are out of bounds, an [IndexOutOfBoundsException] is thrown.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColsColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[`cols`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.cols]`(1, 3, 2) }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[`colsOf`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[`Int`][Int]`>()`[`[`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.get]`5, 1, 2`[`]`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.get]` }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "myColumnGroup".`[`cols`][kotlin.String.cols]`(0, 2) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[`select`][DataFrame.select]`  {  `[`cols`][ColumnsSelectionDsl.cols]`(1, 3) }`
+     *
+     * `df.`[`select`][DataFrame.select]`  {  `[`cols`][ColumnsSelectionDsl.cols]`<`[`String`][String]`>(1, 3) }`
+     *
+     * @throws [IndexOutOfBoundsException] If any index is out of bounds.
+     * @param [firstIndex] The index of the first column to retrieve.
+     * @param [otherIndices] The other indices of the columns to retrieve.
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing the columns found at the given indices.
+     */
+    private interface ColumnsSelectionDslColsIndicesDocs
+
+    /** ## Cols: Columns by Indices
+     *
+     * Retrieves one or multiple columns from [this] in the form of a [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] by their indices.
+     * If any of the indices are out of bounds, an [IndexOutOfBoundsException] is thrown.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColsColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[`cols`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.cols]`(1, 3, 2) }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[`colsOf`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[`Int`][Int]`>()`[`[`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.get]`5, 1, 2`[`]`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.get]` }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "myColumnGroup".`[`cols`][kotlin.String.cols]`(0, 2) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[`cols`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`(1, 3) }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[`cols`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`<`[`String`][String]`>(1, 3) }`
+     *
+     * @throws [IndexOutOfBoundsException] If any index is out of bounds.
+     * @param [firstIndex] The index of the first column to retrieve.
+     * @param [otherIndices] The other indices of the columns to retrieve.
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing the columns found at the given indices.
+     */
+    @Suppress("INAPPLICABLE_JVM_NAME")
+    @JvmName("colsUnTyped")
+    public fun ColumnsSelectionDsl<*>.cols(firstIndex: Int, vararg otherIndices: Int): ColumnSet<*> =
+        cols<Any?>(firstIndex, *otherIndices)
+
+    /** ## Cols: Columns by Indices
+     *
+     * Retrieves one or multiple columns from [this] in the form of a [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] by their indices.
+     * If any of the indices are out of bounds, an [IndexOutOfBoundsException] is thrown.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColsColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[`cols`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.cols]`(1, 3, 2) }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[`colsOf`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[`Int`][Int]`>()`[`[`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.get]`5, 1, 2`[`]`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.get]` }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "myColumnGroup".`[`cols`][kotlin.String.cols]`(0, 2) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[`cols`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`(1, 3) }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[`cols`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`<`[`String`][String]`>(1, 3) }`
+     *
+     * @throws [IndexOutOfBoundsException] If any index is out of bounds.
+     * @param [firstIndex] The index of the first column to retrieve.
+     * @param [otherIndices] The other indices of the columns to retrieve.
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing the columns found at the given indices.
+     */
+    public fun <T> ColumnsSelectionDsl<*>.cols(firstIndex: Int, vararg otherIndices: Int): ColumnSet<T> =
+        this.asSingleColumn().colsInternal(headPlusArray(firstIndex, otherIndices)).cast()
+
+    /**
+     * ## Cols: Columns by Indices
+     *
+     * Retrieves one or multiple columns from [this] in the form of a [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] by their indices.
+     * If any of the indices are out of bounds, an [IndexOutOfBoundsException] is thrown.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColsColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[`cols`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.cols]`(1, 3, 2) }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[`colsOf`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[`Int`][Int]`>()`[`[`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.get]`5, 1, 2`[`]`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.get]` }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "myColumnGroup".`[`cols`][kotlin.String.cols]`(0, 2) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[`select`][DataFrame.select]` { myColumnGroup.`[`cols`][SingleColumn.cols]`(1, 3) }`
+     *
+     * `df.`[`select`][DataFrame.select]` { myColumnGroup.`[`cols`][SingleColumn.cols]`<`[`String`][String]`>(3, 4) }`
+     *
+     * @throws [IndexOutOfBoundsException] If any index is out of bounds.
+     * @param [firstIndex] The index of the first column to retrieve.
+     * @param [otherIndices] The other indices of the columns to retrieve.
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing the columns found at the given indices.
+     */
+    private interface SingleColumnColsIndicesDocs
+
+    /** ## Cols: Columns by Indices
+     *
+     * Retrieves one or multiple columns from [this] in the form of a [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] by their indices.
+     * If any of the indices are out of bounds, an [IndexOutOfBoundsException] is thrown.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColsColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[`cols`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.cols]`(1, 3, 2) }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[`colsOf`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[`Int`][Int]`>()`[`[`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.get]`5, 1, 2`[`]`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.get]` }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "myColumnGroup".`[`cols`][kotlin.String.cols]`(0, 2) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[`cols`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.cols]`(1, 3) }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[`cols`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.cols]`<`[`String`][String]`>(3, 4) }`
+     *
+     * @throws [IndexOutOfBoundsException] If any index is out of bounds.
+     * @param [firstIndex] The index of the first column to retrieve.
+     * @param [otherIndices] The other indices of the columns to retrieve.
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing the columns found at the given indices.
+     */
+    @Suppress("INAPPLICABLE_JVM_NAME")
+    @JvmName("colsUnTyped")
+    public fun SingleColumn<DataRow<*>>.cols(firstIndex: Int, vararg otherIndices: Int): ColumnSet<*> =
+        cols<Any?>(firstIndex, *otherIndices)
+
+    /** ## Cols: Columns by Indices
+     *
+     * Retrieves one or multiple columns from [this] in the form of a [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] by their indices.
+     * If any of the indices are out of bounds, an [IndexOutOfBoundsException] is thrown.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColsColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[`cols`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.cols]`(1, 3, 2) }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[`colsOf`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[`Int`][Int]`>()`[`[`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.get]`5, 1, 2`[`]`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.get]` }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "myColumnGroup".`[`cols`][kotlin.String.cols]`(0, 2) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[`cols`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.cols]`(1, 3) }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[`cols`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.cols]`<`[`String`][String]`>(3, 4) }`
+     *
+     * @throws [IndexOutOfBoundsException] If any index is out of bounds.
+     * @param [firstIndex] The index of the first column to retrieve.
+     * @param [otherIndices] The other indices of the columns to retrieve.
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing the columns found at the given indices.
+     */
+    public fun <T> SingleColumn<DataRow<*>>.cols(firstIndex: Int, vararg otherIndices: Int): ColumnSet<T> =
+        this.ensureIsColumnGroup().colsInternal(headPlusArray(firstIndex, otherIndices)).cast()
+
+    /**
+     * ## Cols: Columns by Indices
+     *
+     * Retrieves one or multiple columns from [this] in the form of a [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] by their indices.
+     * If any of the indices are out of bounds, an [IndexOutOfBoundsException] is thrown.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColsColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[`cols`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.cols]`(1, 3, 2) }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[`colsOf`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[`Int`][Int]`>()`[`[`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.get]`5, 1, 2`[`]`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.get]` }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "myColumnGroup".`[`cols`][kotlin.String.cols]`(0, 2) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[`select`][DataFrame.select]` { "myColumnGroup".`[`cols`][String.cols]`(5, 3, 1) }`
+     *
+     * `df.`[`select`][DataFrame.select]` { "myColumnGroup".`[`cols`][String.cols]`<`[`String`][String]`>(5, 3, 1) }`
+     *
+     * @throws [IndexOutOfBoundsException] If any index is out of bounds.
+     * @param [firstIndex] The index of the first column to retrieve.
+     * @param [otherIndices] The other indices of the columns to retrieve.
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing the columns found at the given indices.
+     */
+    private interface StringColsIndicesDocs
+
+    /** ## Cols: Columns by Indices
+     *
+     * Retrieves one or multiple columns from [this] in the form of a [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] by their indices.
+     * If any of the indices are out of bounds, an [IndexOutOfBoundsException] is thrown.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColsColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[`cols`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.cols]`(1, 3, 2) }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[`colsOf`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[`Int`][Int]`>()`[`[`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.get]`5, 1, 2`[`]`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.get]` }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "myColumnGroup".`[`cols`][kotlin.String.cols]`(0, 2) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "myColumnGroup".`[`cols`][kotlin.String.cols]`(5, 3, 1) }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "myColumnGroup".`[`cols`][kotlin.String.cols]`<`[`String`][String]`>(5, 3, 1) }`
+     *
+     * @throws [IndexOutOfBoundsException] If any index is out of bounds.
+     * @param [firstIndex] The index of the first column to retrieve.
+     * @param [otherIndices] The other indices of the columns to retrieve.
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing the columns found at the given indices.
+     */
+    @Suppress("INAPPLICABLE_JVM_NAME")
+    @JvmName("colsUnTyped")
+    public fun String.cols(firstIndex: Int, vararg otherIndices: Int): ColumnSet<*> =
+        cols<Any?>(firstIndex, *otherIndices)
+
+    /** ## Cols: Columns by Indices
+     *
+     * Retrieves one or multiple columns from [this] in the form of a [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] by their indices.
+     * If any of the indices are out of bounds, an [IndexOutOfBoundsException] is thrown.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColsColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[`cols`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.cols]`(1, 3, 2) }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[`colsOf`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[`Int`][Int]`>()`[`[`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.get]`5, 1, 2`[`]`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.get]` }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "myColumnGroup".`[`cols`][kotlin.String.cols]`(0, 2) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "myColumnGroup".`[`cols`][kotlin.String.cols]`(5, 3, 1) }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "myColumnGroup".`[`cols`][kotlin.String.cols]`<`[`String`][String]`>(5, 3, 1) }`
+     *
+     * @throws [IndexOutOfBoundsException] If any index is out of bounds.
+     * @param [firstIndex] The index of the first column to retrieve.
+     * @param [otherIndices] The other indices of the columns to retrieve.
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing the columns found at the given indices.
+     */
+    public fun <T> String.cols(firstIndex: Int, vararg otherIndices: Int): ColumnSet<T> =
+        columnGroup(this).cols(firstIndex, *otherIndices).cast()
+
+    /**
+     * ## Cols: Columns by Indices
+     *
+     * Retrieves one or multiple columns from [this] in the form of a [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] by their indices.
+     * If any of the indices are out of bounds, an [IndexOutOfBoundsException] is thrown.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColsColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[`cols`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.cols]`(1, 3, 2) }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[`colsOf`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[`Int`][Int]`>()`[`[`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.get]`5, 1, 2`[`]`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.get]` }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "myColumnGroup".`[`cols`][kotlin.String.cols]`(0, 2) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[`select`][DataFrame.select]` { Type::myColumnGroup.`[`cols`][SingleColumn.cols]`(5, 4) }`
+     *
+     * `df.`[`select`][DataFrame.select]` { Type::myColumnGroup.`[`cols`][SingleColumn.cols]`<`[`String`][String]`>(5, 4) }`
+     *
+     * @throws [IndexOutOfBoundsException] If any index is out of bounds.
+     * @param [firstIndex] The index of the first column to retrieve.
+     * @param [otherIndices] The other indices of the columns to retrieve.
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing the columns found at the given indices.
+     */
+    private interface KPropertyColsIndicesDocs
+
+    /** ## Cols: Columns by Indices
+     *
+     * Retrieves one or multiple columns from [this] in the form of a [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] by their indices.
+     * If any of the indices are out of bounds, an [IndexOutOfBoundsException] is thrown.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColsColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[`cols`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.cols]`(1, 3, 2) }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[`colsOf`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[`Int`][Int]`>()`[`[`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.get]`5, 1, 2`[`]`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.get]` }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "myColumnGroup".`[`cols`][kotlin.String.cols]`(0, 2) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { Type::myColumnGroup.`[`cols`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.cols]`(5, 4) }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { Type::myColumnGroup.`[`cols`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.cols]`<`[`String`][String]`>(5, 4) }`
+     *
+     * @throws [IndexOutOfBoundsException] If any index is out of bounds.
+     * @param [firstIndex] The index of the first column to retrieve.
+     * @param [otherIndices] The other indices of the columns to retrieve.
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing the columns found at the given indices.
+     */
+    @Suppress("INAPPLICABLE_JVM_NAME")
+    @JvmName("colsUnTyped")
+    public fun KProperty<*>.cols(firstIndex: Int, vararg otherIndices: Int): ColumnSet<*> =
+        cols<Any?>(firstIndex, *otherIndices)
+
+    /** ## Cols: Columns by Indices
+     *
+     * Retrieves one or multiple columns from [this] in the form of a [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] by their indices.
+     * If any of the indices are out of bounds, an [IndexOutOfBoundsException] is thrown.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColsColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[`cols`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.cols]`(1, 3, 2) }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[`colsOf`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[`Int`][Int]`>()`[`[`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.get]`5, 1, 2`[`]`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.get]` }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "myColumnGroup".`[`cols`][kotlin.String.cols]`(0, 2) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { Type::myColumnGroup.`[`cols`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.cols]`(5, 4) }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { Type::myColumnGroup.`[`cols`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.cols]`<`[`String`][String]`>(5, 4) }`
+     *
+     * @throws [IndexOutOfBoundsException] If any index is out of bounds.
+     * @param [firstIndex] The index of the first column to retrieve.
+     * @param [otherIndices] The other indices of the columns to retrieve.
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing the columns found at the given indices.
+     */
+    public fun <T> KProperty<*>.cols(firstIndex: Int, vararg otherIndices: Int): ColumnSet<T> =
+        columnGroup(this).cols(firstIndex, *otherIndices).cast()
+
+    /**
+     * ## Cols: Columns by Indices
+     *
+     * Retrieves one or multiple columns from [this] in the form of a [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] by their indices.
+     * If any of the indices are out of bounds, an [IndexOutOfBoundsException] is thrown.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColsColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[`cols`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.cols]`(1, 3, 2) }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[`colsOf`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[`Int`][Int]`>()`[`[`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.get]`5, 1, 2`[`]`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.get]` }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "myColumnGroup".`[`cols`][kotlin.String.cols]`(0, 2) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[`select`][DataFrame.select]` { "pathTo"["myColGroup"].`[`cols`][ColumnPath.cols]`(0, 1) }`
+     *
+     * `df.`[`select`][DataFrame.select]` { "pathTo"["myColGroup"].`[`cols`][ColumnPath.cols]`<`[`String`][String]`>(0, 1) }`
+     *
+     * @throws [IndexOutOfBoundsException] If any index is out of bounds.
+     * @param [firstIndex] The index of the first column to retrieve.
+     * @param [otherIndices] The other indices of the columns to retrieve.
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing the columns found at the given indices.
+     */
+    private interface ColumnPathColsIndicesDocs
+
+    /** ## Cols: Columns by Indices
+     *
+     * Retrieves one or multiple columns from [this] in the form of a [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] by their indices.
+     * If any of the indices are out of bounds, an [IndexOutOfBoundsException] is thrown.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColsColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[`cols`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.cols]`(1, 3, 2) }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[`colsOf`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[`Int`][Int]`>()`[`[`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.get]`5, 1, 2`[`]`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.get]` }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "myColumnGroup".`[`cols`][kotlin.String.cols]`(0, 2) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "pathTo"["myColGroup"].`[`cols`][org.jetbrains.kotlinx.dataframe.columns.ColumnPath.cols]`(0, 1) }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "pathTo"["myColGroup"].`[`cols`][org.jetbrains.kotlinx.dataframe.columns.ColumnPath.cols]`<`[`String`][String]`>(0, 1) }`
+     *
+     * @throws [IndexOutOfBoundsException] If any index is out of bounds.
+     * @param [firstIndex] The index of the first column to retrieve.
+     * @param [otherIndices] The other indices of the columns to retrieve.
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing the columns found at the given indices.
+     */
+    @Suppress("INAPPLICABLE_JVM_NAME")
+    @JvmName("colsUnTyped")
+    public fun ColumnPath.cols(firstIndex: Int, vararg otherIndices: Int): ColumnSet<*> =
+        cols<Any?>(firstIndex, *otherIndices)
+
+    /** ## Cols: Columns by Indices
+     *
+     * Retrieves one or multiple columns from [this] in the form of a [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] by their indices.
+     * If any of the indices are out of bounds, an [IndexOutOfBoundsException] is thrown.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColsColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[`cols`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.cols]`(1, 3, 2) }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[`colsOf`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[`Int`][Int]`>()`[`[`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.get]`5, 1, 2`[`]`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.get]` }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "myColumnGroup".`[`cols`][kotlin.String.cols]`(0, 2) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "pathTo"["myColGroup"].`[`cols`][org.jetbrains.kotlinx.dataframe.columns.ColumnPath.cols]`(0, 1) }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "pathTo"["myColGroup"].`[`cols`][org.jetbrains.kotlinx.dataframe.columns.ColumnPath.cols]`<`[`String`][String]`>(0, 1) }`
+     *
+     * @throws [IndexOutOfBoundsException] If any index is out of bounds.
+     * @param [firstIndex] The index of the first column to retrieve.
+     * @param [otherIndices] The other indices of the columns to retrieve.
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing the columns found at the given indices.
+     */
+    public fun <T> ColumnPath.cols(firstIndex: Int, vararg otherIndices: Int): ColumnSet<T> =
+        columnGroup(this).cols(firstIndex, *otherIndices).cast()
+
+    // endregion
+
+    // region ranges
+
+    /**
+     * ## Cols: Columns by Index Range
+     *
+     * Retrieves multiple columns from [this] in the form of a [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] by a [range] of indices.
+     * If any of the indices in the [range] are out of bounds, an [IndexOutOfBoundsException] is thrown.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColsColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[`cols`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.cols]`(1`[`..`][Int.rangeTo]`3) }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[`colsOf`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[`Int`][Int]`>()`[`[`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.cols]`1`[`..`][Int.rangeTo]`5`[`]`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.cols]` }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "myColGroup".`[`cols`][kotlin.String.cols]`(0`[`..`][Int.rangeTo]`2) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[`select`][DataFrame.select]`  {  `[`colsOf`][SingleColumn.colsOf]`<`[`Int`][Int]`>().`[`cols`][ColumnSet.cols]`(1`[`..`][Int.rangeTo]`3) }`
+     *
+     * `df.`[`select`][DataFrame.select]`  {  `[`all`][all]`()`[`[`][ColumnSet.cols]`1`[`..`][Int.rangeTo]`5`[`]`][ColumnSet.cols]` }`
+     *
+     * @throws [IndexOutOfBoundsException] if any of the indices in the [range] are out of bounds.
+     * @throws [IllegalArgumentException] if the [range] is empty.
+     * @param [range] The range of indices to retrieve in the form of an [IntRange].
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing the columns found at the given indices.
+     */
+    private interface ColumnSetColsRangeDocs
+
+    /** ## Cols: Columns by Index Range
+     *
+     * Retrieves multiple columns from [this] in the form of a [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] by a [range] of indices.
+     * If any of the indices in the [range] are out of bounds, an [IndexOutOfBoundsException] is thrown.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColsColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[`cols`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.cols]`(1`[`..`][Int.rangeTo]`3) }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[`colsOf`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[`Int`][Int]`>()`[`[`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.cols]`1`[`..`][Int.rangeTo]`5`[`]`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.cols]` }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "myColGroup".`[`cols`][kotlin.String.cols]`(0`[`..`][Int.rangeTo]`2) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[`colsOf`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.colsOf]`<`[`Int`][Int]`>().`[`cols`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.cols]`(1`[`..`][Int.rangeTo]`3) }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[`all`][org.jetbrains.kotlinx.dataframe.api.all]`()`[`[`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.cols]`1`[`..`][Int.rangeTo]`5`[`]`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.cols]` }`
+     *
+     * @throws [IndexOutOfBoundsException] if any of the indices in the [range] are out of bounds.
+     * @throws [IllegalArgumentException] if the [range] is empty.
+     * @param [range] The range of indices to retrieve in the form of an [IntRange].
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing the columns found at the given indices.
+     */
+    @Suppress("UNCHECKED_CAST")
+    public fun <C> ColumnSet<C>.cols(range: IntRange): ColumnSet<C> = colsInternal(range) as ColumnSet<C>
+
+    /** ## Cols: Columns by Index Range
+     *
+     * Retrieves multiple columns from [this] in the form of a [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] by a [range] of indices.
+     * If any of the indices in the [range] are out of bounds, an [IndexOutOfBoundsException] is thrown.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColsColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[`cols`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.cols]`(1`[`..`][Int.rangeTo]`3) }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[`colsOf`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[`Int`][Int]`>()`[`[`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.cols]`1`[`..`][Int.rangeTo]`5`[`]`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.cols]` }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "myColGroup".`[`cols`][kotlin.String.cols]`(0`[`..`][Int.rangeTo]`2) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[`colsOf`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.colsOf]`<`[`Int`][Int]`>().`[`cols`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.cols]`(1`[`..`][Int.rangeTo]`3) }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[`all`][org.jetbrains.kotlinx.dataframe.api.all]`()`[`[`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.cols]`1`[`..`][Int.rangeTo]`5`[`]`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.cols]` }`
+     *
+     * @throws [IndexOutOfBoundsException] if any of the indices in the [range] are out of bounds.
+     * @throws [IllegalArgumentException] if the [range] is empty.
+     * @param [range] The range of indices to retrieve in the form of an [IntRange].
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing the columns found at the given indices.
+     */
+    public operator fun <C> ColumnSet<C>.get(range: IntRange): ColumnSet<C> = cols(range)
+
+    /**
+     * ## Cols: Columns by Index Range
+     *
+     * Retrieves multiple columns from [this] in the form of a [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] by a [range] of indices.
+     * If any of the indices in the [range] are out of bounds, an [IndexOutOfBoundsException] is thrown.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColsColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[`cols`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.cols]`(1`[`..`][Int.rangeTo]`3) }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[`colsOf`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[`Int`][Int]`>()`[`[`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.cols]`1`[`..`][Int.rangeTo]`5`[`]`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.cols]` }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "myColGroup".`[`cols`][kotlin.String.cols]`(0`[`..`][Int.rangeTo]`2) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[`select`][DataFrame.select]`  {  `[`cols`][ColumnsSelectionDsl.cols]`(1`[`..`][Int.rangeTo]`3) }`
+     *
+     * `df.`[`select`][DataFrame.select]`  {  `[`cols`][ColumnsSelectionDsl.cols]`<`[`String`][String]`>(1`[`..`][Int.rangeTo]`3) }`
+     *
+     * @throws [IndexOutOfBoundsException] if any of the indices in the [range] are out of bounds.
+     * @throws [IllegalArgumentException] if the [range] is empty.
+     * @param [range] The range of indices to retrieve in the form of an [IntRange].
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing the columns found at the given indices.
+     */
+    private interface ColumnsSelectionDslColsRangeDocs
+
+    /** ## Cols: Columns by Index Range
+     *
+     * Retrieves multiple columns from [this] in the form of a [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] by a [range] of indices.
+     * If any of the indices in the [range] are out of bounds, an [IndexOutOfBoundsException] is thrown.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColsColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[`cols`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.cols]`(1`[`..`][Int.rangeTo]`3) }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[`colsOf`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[`Int`][Int]`>()`[`[`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.cols]`1`[`..`][Int.rangeTo]`5`[`]`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.cols]` }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "myColGroup".`[`cols`][kotlin.String.cols]`(0`[`..`][Int.rangeTo]`2) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[`cols`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`(1`[`..`][Int.rangeTo]`3) }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[`cols`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`<`[`String`][String]`>(1`[`..`][Int.rangeTo]`3) }`
+     *
+     * @throws [IndexOutOfBoundsException] if any of the indices in the [range] are out of bounds.
+     * @throws [IllegalArgumentException] if the [range] is empty.
+     * @param [range] The range of indices to retrieve in the form of an [IntRange].
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing the columns found at the given indices.
+     */
+    @Suppress("INAPPLICABLE_JVM_NAME")
+    @JvmName("colsUnTyped")
+    public fun ColumnsSelectionDsl<*>.cols(range: IntRange): ColumnSet<*> = cols<Any?>(range)
+
+    /** ## Cols: Columns by Index Range
+     *
+     * Retrieves multiple columns from [this] in the form of a [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] by a [range] of indices.
+     * If any of the indices in the [range] are out of bounds, an [IndexOutOfBoundsException] is thrown.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColsColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[`cols`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.cols]`(1`[`..`][Int.rangeTo]`3) }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[`colsOf`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[`Int`][Int]`>()`[`[`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.cols]`1`[`..`][Int.rangeTo]`5`[`]`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.cols]` }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "myColGroup".`[`cols`][kotlin.String.cols]`(0`[`..`][Int.rangeTo]`2) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[`cols`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`(1`[`..`][Int.rangeTo]`3) }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[`cols`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`<`[`String`][String]`>(1`[`..`][Int.rangeTo]`3) }`
+     *
+     * @throws [IndexOutOfBoundsException] if any of the indices in the [range] are out of bounds.
+     * @throws [IllegalArgumentException] if the [range] is empty.
+     * @param [range] The range of indices to retrieve in the form of an [IntRange].
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing the columns found at the given indices.
+     */
+    public fun <T> ColumnsSelectionDsl<*>.cols(range: IntRange): ColumnSet<T> =
+        this.asSingleColumn().colsInternal(range).cast()
+
+    /**
+     * ## Cols: Columns by Index Range
+     *
+     * Retrieves multiple columns from [this] in the form of a [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] by a [range] of indices.
+     * If any of the indices in the [range] are out of bounds, an [IndexOutOfBoundsException] is thrown.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColsColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[`cols`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.cols]`(1`[`..`][Int.rangeTo]`3) }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[`colsOf`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[`Int`][Int]`>()`[`[`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.cols]`1`[`..`][Int.rangeTo]`5`[`]`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.cols]` }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "myColGroup".`[`cols`][kotlin.String.cols]`(0`[`..`][Int.rangeTo]`2) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[`select`][DataFrame.select]` { myColumnGroup.`[`cols`][SingleColumn.cols]`(1`[`..`][Int.rangeTo]`3) }`
+     *
+     * `df.`[`select`][DataFrame.select]` { myColumnGroup.`[`cols`][SingleColumn.cols]`<`[`String`][String]`>(1`[`..`][Int.rangeTo]`3) }`
+     *
+     * @throws [IndexOutOfBoundsException] if any of the indices in the [range] are out of bounds.
+     * @throws [IllegalArgumentException] if the [range] is empty.
+     * @param [range] The range of indices to retrieve in the form of an [IntRange].
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing the columns found at the given indices.
+     */
+    private interface SingleColumnColsRangeDocs
+
+    /** ## Cols: Columns by Index Range
+     *
+     * Retrieves multiple columns from [this] in the form of a [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] by a [range] of indices.
+     * If any of the indices in the [range] are out of bounds, an [IndexOutOfBoundsException] is thrown.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColsColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[`cols`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.cols]`(1`[`..`][Int.rangeTo]`3) }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[`colsOf`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[`Int`][Int]`>()`[`[`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.cols]`1`[`..`][Int.rangeTo]`5`[`]`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.cols]` }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "myColGroup".`[`cols`][kotlin.String.cols]`(0`[`..`][Int.rangeTo]`2) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[`cols`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.cols]`(1`[`..`][Int.rangeTo]`3) }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[`cols`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.cols]`<`[`String`][String]`>(1`[`..`][Int.rangeTo]`3) }`
+     *
+     * @throws [IndexOutOfBoundsException] if any of the indices in the [range] are out of bounds.
+     * @throws [IllegalArgumentException] if the [range] is empty.
+     * @param [range] The range of indices to retrieve in the form of an [IntRange].
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing the columns found at the given indices.
+     */
+    @Suppress("INAPPLICABLE_JVM_NAME")
+    @JvmName("colsUnTyped")
+    public fun SingleColumn<DataRow<*>>.cols(range: IntRange): ColumnSet<*> = cols<Any?>(range)
+
+    /** ## Cols: Columns by Index Range
+     *
+     * Retrieves multiple columns from [this] in the form of a [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] by a [range] of indices.
+     * If any of the indices in the [range] are out of bounds, an [IndexOutOfBoundsException] is thrown.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColsColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[`cols`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.cols]`(1`[`..`][Int.rangeTo]`3) }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[`colsOf`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[`Int`][Int]`>()`[`[`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.cols]`1`[`..`][Int.rangeTo]`5`[`]`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.cols]` }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "myColGroup".`[`cols`][kotlin.String.cols]`(0`[`..`][Int.rangeTo]`2) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[`cols`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.cols]`(1`[`..`][Int.rangeTo]`3) }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[`cols`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.cols]`<`[`String`][String]`>(1`[`..`][Int.rangeTo]`3) }`
+     *
+     * @throws [IndexOutOfBoundsException] if any of the indices in the [range] are out of bounds.
+     * @throws [IllegalArgumentException] if the [range] is empty.
+     * @param [range] The range of indices to retrieve in the form of an [IntRange].
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing the columns found at the given indices.
+     */
+    public fun <T> SingleColumn<DataRow<*>>.cols(range: IntRange): ColumnSet<T> =
+        this.ensureIsColumnGroup().colsInternal(range).cast()
+
+    /**
+     * ## Cols: Columns by Index Range
+     *
+     * Retrieves multiple columns from [this] in the form of a [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] by a [range] of indices.
+     * If any of the indices in the [range] are out of bounds, an [IndexOutOfBoundsException] is thrown.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColsColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[`cols`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.cols]`(1`[`..`][Int.rangeTo]`3) }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[`colsOf`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[`Int`][Int]`>()`[`[`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.cols]`1`[`..`][Int.rangeTo]`5`[`]`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.cols]` }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "myColGroup".`[`cols`][kotlin.String.cols]`(0`[`..`][Int.rangeTo]`2) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[`select`][DataFrame.select]` { "myColGroup".`[`cols`][String.cols]`(1`[`..`][Int.rangeTo]`3) }`
+     *
+     * `df.`[`select`][DataFrame.select]` { "myColGroup".`[`cols`][String.cols]`<`[`String`][String]`>(1`[`..`][Int.rangeTo]`3) }`
+     *
+     * @throws [IndexOutOfBoundsException] if any of the indices in the [range] are out of bounds.
+     * @throws [IllegalArgumentException] if the [range] is empty.
+     * @param [range] The range of indices to retrieve in the form of an [IntRange].
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing the columns found at the given indices.
+     */
+    private interface StringColsRangeDocs
+
+    /** ## Cols: Columns by Index Range
+     *
+     * Retrieves multiple columns from [this] in the form of a [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] by a [range] of indices.
+     * If any of the indices in the [range] are out of bounds, an [IndexOutOfBoundsException] is thrown.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColsColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[`cols`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.cols]`(1`[`..`][Int.rangeTo]`3) }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[`colsOf`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[`Int`][Int]`>()`[`[`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.cols]`1`[`..`][Int.rangeTo]`5`[`]`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.cols]` }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "myColGroup".`[`cols`][kotlin.String.cols]`(0`[`..`][Int.rangeTo]`2) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "myColGroup".`[`cols`][kotlin.String.cols]`(1`[`..`][Int.rangeTo]`3) }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "myColGroup".`[`cols`][kotlin.String.cols]`<`[`String`][String]`>(1`[`..`][Int.rangeTo]`3) }`
+     *
+     * @throws [IndexOutOfBoundsException] if any of the indices in the [range] are out of bounds.
+     * @throws [IllegalArgumentException] if the [range] is empty.
+     * @param [range] The range of indices to retrieve in the form of an [IntRange].
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing the columns found at the given indices.
+     */
+    @Suppress("INAPPLICABLE_JVM_NAME")
+    @JvmName("colsUnTyped")
+    public fun String.cols(range: IntRange): ColumnSet<*> = cols<Any?>(range)
+
+    /** ## Cols: Columns by Index Range
+     *
+     * Retrieves multiple columns from [this] in the form of a [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] by a [range] of indices.
+     * If any of the indices in the [range] are out of bounds, an [IndexOutOfBoundsException] is thrown.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColsColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[`cols`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.cols]`(1`[`..`][Int.rangeTo]`3) }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[`colsOf`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[`Int`][Int]`>()`[`[`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.cols]`1`[`..`][Int.rangeTo]`5`[`]`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.cols]` }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "myColGroup".`[`cols`][kotlin.String.cols]`(0`[`..`][Int.rangeTo]`2) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "myColGroup".`[`cols`][kotlin.String.cols]`(1`[`..`][Int.rangeTo]`3) }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "myColGroup".`[`cols`][kotlin.String.cols]`<`[`String`][String]`>(1`[`..`][Int.rangeTo]`3) }`
+     *
+     * @throws [IndexOutOfBoundsException] if any of the indices in the [range] are out of bounds.
+     * @throws [IllegalArgumentException] if the [range] is empty.
+     * @param [range] The range of indices to retrieve in the form of an [IntRange].
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing the columns found at the given indices.
+     */
+    public fun <T> String.cols(range: IntRange): ColumnSet<T> = columnGroup(this).cols(range).cast()
+
+    /**
+     * ## Cols: Columns by Index Range
+     *
+     * Retrieves multiple columns from [this] in the form of a [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] by a [range] of indices.
+     * If any of the indices in the [range] are out of bounds, an [IndexOutOfBoundsException] is thrown.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColsColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[`cols`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.cols]`(1`[`..`][Int.rangeTo]`3) }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[`colsOf`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[`Int`][Int]`>()`[`[`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.cols]`1`[`..`][Int.rangeTo]`5`[`]`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.cols]` }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "myColGroup".`[`cols`][kotlin.String.cols]`(0`[`..`][Int.rangeTo]`2) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[`select`][DataFrame.select]` { Type::myColumnGroup.`[`cols`][SingleColumn.cols]`(1`[`..`][Int.rangeTo]`3) }`
+     *
+     * `df.`[`select`][DataFrame.select]` { Type::myColumnGroup.`[`cols`][SingleColumn.cols]`<`[`String`][String]`>(1`[`..`][Int.rangeTo]`3) }`
+     *
+     *
+     * @throws [IndexOutOfBoundsException] if any of the indices in the [range] are out of bounds.
+     * @throws [IllegalArgumentException] if the [range] is empty.
+     * @param [range] The range of indices to retrieve in the form of an [IntRange].
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing the columns found at the given indices.
+     */
+    private interface KPropertyColsRangeDocs
+
+    /** ## Cols: Columns by Index Range
+     *
+     * Retrieves multiple columns from [this] in the form of a [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] by a [range] of indices.
+     * If any of the indices in the [range] are out of bounds, an [IndexOutOfBoundsException] is thrown.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColsColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[`cols`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.cols]`(1`[`..`][Int.rangeTo]`3) }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[`colsOf`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[`Int`][Int]`>()`[`[`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.cols]`1`[`..`][Int.rangeTo]`5`[`]`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.cols]` }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "myColGroup".`[`cols`][kotlin.String.cols]`(0`[`..`][Int.rangeTo]`2) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { Type::myColumnGroup.`[`cols`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.cols]`(1`[`..`][Int.rangeTo]`3) }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { Type::myColumnGroup.`[`cols`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.cols]`<`[`String`][String]`>(1`[`..`][Int.rangeTo]`3) }`
+     *
+     * @throws [IndexOutOfBoundsException] if any of the indices in the [range] are out of bounds.
+     * @throws [IllegalArgumentException] if the [range] is empty.
+     * @param [range] The range of indices to retrieve in the form of an [IntRange].
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing the columns found at the given indices.
+     */
+    @Suppress("INAPPLICABLE_JVM_NAME")
+    @JvmName("colsUnTyped")
+    public fun KProperty<*>.cols(range: IntRange): ColumnSet<*> = cols<Any?>(range)
+
+    /** ## Cols: Columns by Index Range
+     *
+     * Retrieves multiple columns from [this] in the form of a [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] by a [range] of indices.
+     * If any of the indices in the [range] are out of bounds, an [IndexOutOfBoundsException] is thrown.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColsColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[`cols`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.cols]`(1`[`..`][Int.rangeTo]`3) }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[`colsOf`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[`Int`][Int]`>()`[`[`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.cols]`1`[`..`][Int.rangeTo]`5`[`]`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.cols]` }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "myColGroup".`[`cols`][kotlin.String.cols]`(0`[`..`][Int.rangeTo]`2) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { Type::myColumnGroup.`[`cols`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.cols]`(1`[`..`][Int.rangeTo]`3) }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { Type::myColumnGroup.`[`cols`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.cols]`<`[`String`][String]`>(1`[`..`][Int.rangeTo]`3) }`
+     *
+     * @throws [IndexOutOfBoundsException] if any of the indices in the [range] are out of bounds.
+     * @throws [IllegalArgumentException] if the [range] is empty.
+     * @param [range] The range of indices to retrieve in the form of an [IntRange].
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing the columns found at the given indices.
+     */
+    public fun <T> KProperty<*>.cols(range: IntRange): ColumnSet<T> = columnGroup(this).cols(range).cast()
+
+    /**
+     * ## Cols: Columns by Index Range
+     *
+     * Retrieves multiple columns from [this] in the form of a [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] by a [range] of indices.
+     * If any of the indices in the [range] are out of bounds, an [IndexOutOfBoundsException] is thrown.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColsColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[`cols`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.cols]`(1`[`..`][Int.rangeTo]`3) }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[`colsOf`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[`Int`][Int]`>()`[`[`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.cols]`1`[`..`][Int.rangeTo]`5`[`]`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.cols]` }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "myColGroup".`[`cols`][kotlin.String.cols]`(0`[`..`][Int.rangeTo]`2) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[`select`][DataFrame.select]` { "pathTo"["myColGroup"].`[`cols`][ColumnPath.cols]`(0`[`..`][Int.rangeTo]`1) }`
+     *
+     * `df.`[`select`][DataFrame.select]` { "pathTo"["myColGroup"].`[`cols`][ColumnPath.cols]`<`[`String`][String]`>(0`[`..`][Int.rangeTo]`1) }`
+     *
+     * @throws [IndexOutOfBoundsException] if any of the indices in the [range] are out of bounds.
+     * @throws [IllegalArgumentException] if the [range] is empty.
+     * @param [range] The range of indices to retrieve in the form of an [IntRange].
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing the columns found at the given indices.
+     */
+    private interface ColumnPathColsRangeDocs
+
+    /** ## Cols: Columns by Index Range
+     *
+     * Retrieves multiple columns from [this] in the form of a [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] by a [range] of indices.
+     * If any of the indices in the [range] are out of bounds, an [IndexOutOfBoundsException] is thrown.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColsColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[`cols`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.cols]`(1`[`..`][Int.rangeTo]`3) }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[`colsOf`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[`Int`][Int]`>()`[`[`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.cols]`1`[`..`][Int.rangeTo]`5`[`]`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.cols]` }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "myColGroup".`[`cols`][kotlin.String.cols]`(0`[`..`][Int.rangeTo]`2) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "pathTo"["myColGroup"].`[`cols`][org.jetbrains.kotlinx.dataframe.columns.ColumnPath.cols]`(0`[`..`][Int.rangeTo]`1) }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "pathTo"["myColGroup"].`[`cols`][org.jetbrains.kotlinx.dataframe.columns.ColumnPath.cols]`<`[`String`][String]`>(0`[`..`][Int.rangeTo]`1) }`
+     *
+     * @throws [IndexOutOfBoundsException] if any of the indices in the [range] are out of bounds.
+     * @throws [IllegalArgumentException] if the [range] is empty.
+     * @param [range] The range of indices to retrieve in the form of an [IntRange].
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing the columns found at the given indices.
+     */
+    @Suppress("INAPPLICABLE_JVM_NAME")
+    @JvmName("colsUnTyped")
+    public fun ColumnPath.cols(range: IntRange): ColumnSet<*> = cols<Any?>(range)
+
+    /** ## Cols: Columns by Index Range
+     *
+     * Retrieves multiple columns from [this] in the form of a [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] by a [range] of indices.
+     * If any of the indices in the [range] are out of bounds, an [IndexOutOfBoundsException] is thrown.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColsColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[`cols`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.cols]`(1`[`..`][Int.rangeTo]`3) }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[`colsOf`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[`Int`][Int]`>()`[`[`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.cols]`1`[`..`][Int.rangeTo]`5`[`]`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.cols]` }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "myColGroup".`[`cols`][kotlin.String.cols]`(0`[`..`][Int.rangeTo]`2) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "pathTo"["myColGroup"].`[`cols`][org.jetbrains.kotlinx.dataframe.columns.ColumnPath.cols]`(0`[`..`][Int.rangeTo]`1) }`
+     *
+     * `df.`[`select`][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "pathTo"["myColGroup"].`[`cols`][org.jetbrains.kotlinx.dataframe.columns.ColumnPath.cols]`<`[`String`][String]`>(0`[`..`][Int.rangeTo]`1) }`
+     *
+     * @throws [IndexOutOfBoundsException] if any of the indices in the [range] are out of bounds.
+     * @throws [IllegalArgumentException] if the [range] is empty.
+     * @param [range] The range of indices to retrieve in the form of an [IntRange].
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing the columns found at the given indices.
+     */
+    public fun <T> ColumnPath.cols(range: IntRange): ColumnSet<T> = columnGroup(this).cols(range).cast()
+
+    // endregion
+}
+
+internal fun SingleColumn<DataRow<*>>.colsInternal(refs: Iterable<ColumnReference<*>>): ColumnSet<*> =
+    ensureIsColumnGroup().transformSingle { col ->
+        refs.map {
+            col.getCol(it) ?: throw IllegalArgumentException(
+                "Column at ${col.path.plus(it.path()).joinToString()} was not found.",
+            )
+        }
+    }
+
+/**
+ * If this [ColumnsResolver] is a [SingleColumn], it
+ * returns a new [ColumnSet] containing the columns inside of this [SingleColumn] that
+ * match the given [predicate].
+ *
+ * Else, it returns a new [ColumnSet] containing all columns in this [ColumnsResolver] that
+ * match the given [predicate].
+ */
+internal fun ColumnsResolver<*>.colsInternal(predicate: ColumnFilter<*>): TransformableColumnSet<*> =
+    allColumnsInternal().transform { it.filter(predicate) }
+
+internal fun ColumnsResolver<*>.colsInternal(indices: IntArray): TransformableColumnSet<*> =
+    allColumnsInternal().transform { cols ->
+        indices.map {
+            try {
+                cols[it]
+            } catch (e: IndexOutOfBoundsException) {
+                throw IndexOutOfBoundsException("Index $it is out of bounds for column set of size ${cols.size}")
+            }
+        }
+    }
+
+internal fun ColumnsResolver<*>.colsInternal(range: IntRange): TransformableColumnSet<*> =
+    allColumnsInternal().transform {
+        try {
+            it.subList(range.first, range.last + 1)
+        } catch (e: IndexOutOfBoundsException) {
+            throw IndexOutOfBoundsException("Range $range is out of bounds for column set of size ${it.size}")
+        }
+    }
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/colsAtAnyDepth.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/colsAtAnyDepth.kt
new file mode 100644
index 000000000..f4994c31c
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/colsAtAnyDepth.kt
@@ -0,0 +1,511 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import org.jetbrains.kotlinx.dataframe.ColumnFilter
+import org.jetbrains.kotlinx.dataframe.DataColumn
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.DataRow
+import org.jetbrains.kotlinx.dataframe.annotations.Interpretable
+import org.jetbrains.kotlinx.dataframe.api.ColsAtAnyDepthColumnsSelectionDsl.Grammar
+import org.jetbrains.kotlinx.dataframe.columns.ColumnGroup
+import org.jetbrains.kotlinx.dataframe.columns.ColumnPath
+import org.jetbrains.kotlinx.dataframe.columns.ColumnSet
+import org.jetbrains.kotlinx.dataframe.columns.ColumnsResolver
+import org.jetbrains.kotlinx.dataframe.columns.SingleColumn
+import org.jetbrains.kotlinx.dataframe.impl.columns.atAnyDepthImpl
+import kotlin.reflect.KProperty
+
+// region ColumnsSelectionDsl
+
+/**
+ * ## Cols At Any Depth [Columns Selection DSL][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl]
+ *
+ * See [Grammar] for all functions in this interface.
+ */
+public interface ColsAtAnyDepthColumnsSelectionDsl {
+
+    // region atAnyDepth
+
+    /**
+     * ## Cols At Any Depth Grammar
+     *
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * [(What is this notation?)][org.jetbrains.kotlinx.dataframe.documentation.DslGrammar]
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  ### Definitions:
+     *  `columnSet: `[`ColumnSet`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]`<*>`
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  `columnGroup: `[`SingleColumn`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]`<`[`DataRow`][org.jetbrains.kotlinx.dataframe.DataRow]`<*>> | `[`String`][String]`  |  `[`KProperty`][kotlin.reflect.KProperty]`<* | `[`DataRow`][org.jetbrains.kotlinx.dataframe.DataRow]`<*>> | `[`ColumnPath`][org.jetbrains.kotlinx.dataframe.columns.ColumnPath]
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  `condition: `[`ColumnFilter`][org.jetbrains.kotlinx.dataframe.ColumnFilter]
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  ### What can be called directly in the [Columns Selection DSL][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl]:
+     *
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  [**`colsAtAnyDepth`**][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsAtAnyDepth]`  [  `**`{ `**[`condition`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ConditionDef]**` }`**` ]`
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  ### What can be called on a [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]:
+     *
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  [`columnSet`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ColumnSetDef]
+     *
+     *  &nbsp;&nbsp;&nbsp;&nbsp;__`.`__[**`colsAtAnyDepth`**][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsAtAnyDepth]`  [  `**`{ `**[`condition`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ConditionDef]**` }`**` ]`
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  ### What can be called on a [Column Group (reference)][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ColumnGroupDef]:
+     *
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  [`columnGroup`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ColumnGroupDef]
+     *
+     *  &nbsp;&nbsp;&nbsp;&nbsp;__`.`__[**`colsAtAnyDepth`**][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsAtAnyDepth]`  [  `**`{ `**[`condition`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ConditionDef]**` }`**` ]`
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     */
+    public interface Grammar {
+
+        /** [**`colsAtAnyDepth`**][ColumnsSelectionDsl.colsAtAnyDepth] */
+        public interface PlainDslName
+
+        /** __`.`__[**`colsAtAnyDepth`**][ColumnsSelectionDsl.colsAtAnyDepth] */
+        public interface ColumnSetName
+
+        /** __`.`__[**`colsAtAnyDepth`**][ColumnsSelectionDsl.colsAtAnyDepth] */
+        public interface ColumnGroupName
+    }
+
+    /**
+     * ## Cols At Any Depth
+     *
+     * Returns all columns in [this] at any depth (so also inside [Column Groups][ColumnGroup]) if they satisfy the
+     * optional given predicate.
+     *
+     * This function can also be followed by another [ColumnSet] filter function like
+     * [colsOf][ColumnsSelectionDsl.colsOf], [single][ColumnsSelectionDsl.single], or [valueCols][ColumnsSelectionDsl.valueCols].
+     * ### Check out: [Grammar]
+     * #### For example:
+     * `// Depth-first search to a column containing the value "Alice"`
+     *
+     * `df.`[select][DataFrame.select]`  {  `[colsAtAnyDepth][ColumnsSelectionDsl.colsAtAnyDepth]`().`[first][ColumnsSelectionDsl.firstCol]`  { "Alice"  `[in][Iterable.contains]` it.`[values][DataColumn.values]`() } }`
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * `// The columns at any depth excluding the top-level`
+     *
+     * `df.`[select][DataFrame.select]`  {  `[colGroups][ColumnsSelectionDsl.colGroups]`().`[colsAtAnyDepth][ColumnSet.colsAtAnyDepth]`() }`
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * `// All value- and frame columns at any depth`
+     *
+     * `df.`[select][DataFrame.select]`  {  `[colsAtAnyDepth][ColumnsSelectionDsl.colsAtAnyDepth]` { !it.`[isColumnGroup][DataColumn.isColumnGroup]` } }`
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * `// All value columns at any depth nested under a column group named "myColGroup"`
+     *
+     * `df.`[select][DataFrame.select]` { myColGroup.`[colsAtAnyDepth][SingleColumn.colsAtAnyDepth]`().`[valueCols][ColumnsSelectionDsl.valueCols]`() }`
+     *
+     * #### Examples for this overload:
+     *
+     *
+     *
+     * #### Converting from deprecated syntax:
+     *
+     * `dfs  { condition } -> `[colsAtAnyDepth][colsAtAnyDepth]` { condition }`
+     *
+     * `allDfs(includeGroups = false) -> `[colsAtAnyDepth][colsAtAnyDepth]` { includeGroups || !it.`[isColumnGroup][DataColumn.isColumnGroup]`() }`
+     *
+     * `dfsOf<Type> { condition } -> `[colsAtAnyDepth][colsAtAnyDepth]`().`[colsOf][ColumnsSelectionDsl.colsOf]`<Type> { condition }`
+     *
+     * [cols][ColumnsSelectionDsl.cols]` { condition }.`[recursively][recursively]`() -> `[colsAtAnyDepth][colsAtAnyDepth]` { condition }`
+     *
+     * [first][ColumnsSelectionDsl.first]` { condition }.`[rec][rec]`() -> `[colsAtAnyDepth][colsAtAnyDepth]` { condition }.`[first][ColumnsSelectionDsl.first]`()`
+     *
+     * [all][ColumnsSelectionDsl.all]`().`[recursively][recursively]`() -> `[colsAtAnyDepth][colsAtAnyDepth]`()`
+     *
+     * @see [DataFrame.flatten]
+     * @see [ColumnsSelectionDsl.simplify]
+     */
+    private interface CommonAtAnyDepthDocs {
+
+        /** Example argument */
+        interface Examples
+    }
+
+    /**
+     * ## Cols At Any Depth
+     *
+     * Returns all columns in [this] at any depth (so also inside [Column Groups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup]) if they satisfy the
+     * optional given predicate.
+     *
+     * This function can also be followed by another [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] filter function like
+     * [colsOf][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf], [single][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.single], or [valueCols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.valueCols].
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColsAtAnyDepthColumnsSelectionDsl.Grammar]
+     * #### For example:
+     * `// Depth-first search to a column containing the value "Alice"`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsAtAnyDepth][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsAtAnyDepth]`().`[first][org.jetbrains.kotlinx.dataframe.api.FirstColumnsSelectionDsl.firstCol]`  { "Alice"  `[in][Iterable.contains]` it.`[values][org.jetbrains.kotlinx.dataframe.DataColumn.values]`() } }`
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * `// The columns at any depth excluding the top-level`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroups][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroups]`().`[colsAtAnyDepth][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.colsAtAnyDepth]`() }`
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * `// All value- and frame columns at any depth`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsAtAnyDepth][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsAtAnyDepth]` { !it.`[isColumnGroup][org.jetbrains.kotlinx.dataframe.DataColumn.isColumnGroup]` } }`
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * `// All value columns at any depth nested under a column group named "myColGroup"`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColGroup.`[colsAtAnyDepth][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.colsAtAnyDepth]`().`[valueCols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.valueCols]`() }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][DataFrame.select]`  {  `[colGroups][ColumnsSelectionDsl.colGroups]`().`[colsAtAnyDepth][ColumnsSelectionDsl.colsAtAnyDepth]`  { "Alice"  `[in][Iterable.contains]` it.`[values][DataColumn.values]`() } }`
+     *
+     * #### Converting from deprecated syntax:
+     *
+     * `dfs  { condition } -> `[colsAtAnyDepth][org.jetbrains.kotlinx.dataframe.api.ColsAtAnyDepthColumnsSelectionDsl.colsAtAnyDepth]` { condition }`
+     *
+     * `allDfs(includeGroups = false) -> `[colsAtAnyDepth][org.jetbrains.kotlinx.dataframe.api.ColsAtAnyDepthColumnsSelectionDsl.colsAtAnyDepth]` { includeGroups || !it.`[isColumnGroup][org.jetbrains.kotlinx.dataframe.DataColumn.isColumnGroup]`() }`
+     *
+     * `dfsOf<Type> { condition } -> `[colsAtAnyDepth][org.jetbrains.kotlinx.dataframe.api.ColsAtAnyDepthColumnsSelectionDsl.colsAtAnyDepth]`().`[colsOf][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<Type> { condition }`
+     *
+     * [cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]` { condition }.`[recursively][recursively]`() -> `[colsAtAnyDepth][org.jetbrains.kotlinx.dataframe.api.ColsAtAnyDepthColumnsSelectionDsl.colsAtAnyDepth]` { condition }`
+     *
+     * [first][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.first]` { condition }.`[rec][rec]`() -> `[colsAtAnyDepth][org.jetbrains.kotlinx.dataframe.api.ColsAtAnyDepthColumnsSelectionDsl.colsAtAnyDepth]` { condition }.`[first][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.first]`()`
+     *
+     * [all][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.all]`().`[recursively][recursively]`() -> `[colsAtAnyDepth][org.jetbrains.kotlinx.dataframe.api.ColsAtAnyDepthColumnsSelectionDsl.colsAtAnyDepth]`()`
+     *
+     * @see [DataFrame.flatten]
+     * @see [ColumnsSelectionDsl.simplify]
+     */
+    public fun ColumnSet<*>.colsAtAnyDepth(predicate: ColumnFilter<*> = { true }): ColumnSet<*> =
+        colsAtAnyDepthInternal(predicate)
+
+    /**
+     * ## Cols At Any Depth
+     *
+     * Returns all columns in [this] at any depth (so also inside [Column Groups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup]) if they satisfy the
+     * optional given predicate.
+     *
+     * This function can also be followed by another [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] filter function like
+     * [colsOf][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf], [single][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.single], or [valueCols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.valueCols].
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColsAtAnyDepthColumnsSelectionDsl.Grammar]
+     * #### For example:
+     * `// Depth-first search to a column containing the value "Alice"`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsAtAnyDepth][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsAtAnyDepth]`().`[first][org.jetbrains.kotlinx.dataframe.api.FirstColumnsSelectionDsl.firstCol]`  { "Alice"  `[in][Iterable.contains]` it.`[values][org.jetbrains.kotlinx.dataframe.DataColumn.values]`() } }`
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * `// The columns at any depth excluding the top-level`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroups][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroups]`().`[colsAtAnyDepth][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.colsAtAnyDepth]`() }`
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * `// All value- and frame columns at any depth`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsAtAnyDepth][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsAtAnyDepth]` { !it.`[isColumnGroup][org.jetbrains.kotlinx.dataframe.DataColumn.isColumnGroup]` } }`
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * `// All value columns at any depth nested under a column group named "myColGroup"`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColGroup.`[colsAtAnyDepth][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.colsAtAnyDepth]`().`[valueCols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.valueCols]`() }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][DataFrame.select]`  {  `[colsAtAnyDepth][ColumnsSelectionDsl.colsAtAnyDepth]`  { "Alice"  `[in][Iterable.contains]` it.`[values][DataColumn.values]`() }.`[first][ColumnsSelectionDsl.first]`() }`
+     *
+     * `df.`[select][DataFrame.select]`  {  `[colsAtAnyDepth][ColumnsSelectionDsl.colsAtAnyDepth]` { !it.`[isColumnGroup][DataColumn.isColumnGroup]` } }`
+     *
+     * #### Converting from deprecated syntax:
+     *
+     * `dfs  { condition } -> `[colsAtAnyDepth][org.jetbrains.kotlinx.dataframe.api.ColsAtAnyDepthColumnsSelectionDsl.colsAtAnyDepth]` { condition }`
+     *
+     * `allDfs(includeGroups = false) -> `[colsAtAnyDepth][org.jetbrains.kotlinx.dataframe.api.ColsAtAnyDepthColumnsSelectionDsl.colsAtAnyDepth]` { includeGroups || !it.`[isColumnGroup][org.jetbrains.kotlinx.dataframe.DataColumn.isColumnGroup]`() }`
+     *
+     * `dfsOf<Type> { condition } -> `[colsAtAnyDepth][org.jetbrains.kotlinx.dataframe.api.ColsAtAnyDepthColumnsSelectionDsl.colsAtAnyDepth]`().`[colsOf][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<Type> { condition }`
+     *
+     * [cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]` { condition }.`[recursively][recursively]`() -> `[colsAtAnyDepth][org.jetbrains.kotlinx.dataframe.api.ColsAtAnyDepthColumnsSelectionDsl.colsAtAnyDepth]` { condition }`
+     *
+     * [first][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.first]` { condition }.`[rec][rec]`() -> `[colsAtAnyDepth][org.jetbrains.kotlinx.dataframe.api.ColsAtAnyDepthColumnsSelectionDsl.colsAtAnyDepth]` { condition }.`[first][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.first]`()`
+     *
+     * [all][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.all]`().`[recursively][recursively]`() -> `[colsAtAnyDepth][org.jetbrains.kotlinx.dataframe.api.ColsAtAnyDepthColumnsSelectionDsl.colsAtAnyDepth]`()`
+     *
+     * @see [DataFrame.flatten]
+     * @see [ColumnsSelectionDsl.simplify]
+     */
+    @Interpretable("ColsAtAnyDepth0")
+    public fun ColumnsSelectionDsl<*>.colsAtAnyDepth(predicate: ColumnFilter<*> = { true }): ColumnSet<*> =
+        asSingleColumn().colsAtAnyDepthInternal(predicate)
+
+    /**
+     * ## Cols At Any Depth
+     *
+     * Returns all columns in [this] at any depth (so also inside [Column Groups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup]) if they satisfy the
+     * optional given predicate.
+     *
+     * This function can also be followed by another [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] filter function like
+     * [colsOf][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf], [single][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.single], or [valueCols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.valueCols].
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColsAtAnyDepthColumnsSelectionDsl.Grammar]
+     * #### For example:
+     * `// Depth-first search to a column containing the value "Alice"`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsAtAnyDepth][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsAtAnyDepth]`().`[first][org.jetbrains.kotlinx.dataframe.api.FirstColumnsSelectionDsl.firstCol]`  { "Alice"  `[in][Iterable.contains]` it.`[values][org.jetbrains.kotlinx.dataframe.DataColumn.values]`() } }`
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * `// The columns at any depth excluding the top-level`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroups][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroups]`().`[colsAtAnyDepth][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.colsAtAnyDepth]`() }`
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * `// All value- and frame columns at any depth`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsAtAnyDepth][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsAtAnyDepth]` { !it.`[isColumnGroup][org.jetbrains.kotlinx.dataframe.DataColumn.isColumnGroup]` } }`
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * `// All value columns at any depth nested under a column group named "myColGroup"`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColGroup.`[colsAtAnyDepth][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.colsAtAnyDepth]`().`[valueCols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.valueCols]`() }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][DataFrame.select]` { myColGroup.`[colsAtAnyDepth][SingleColumn.colsAtAnyDepth]`  { "Alice"  `[in][Iterable.contains]` it.`[values][DataColumn.values]`() } }`
+     *
+     * #### Converting from deprecated syntax:
+     *
+     * `dfs  { condition } -> `[colsAtAnyDepth][org.jetbrains.kotlinx.dataframe.api.ColsAtAnyDepthColumnsSelectionDsl.colsAtAnyDepth]` { condition }`
+     *
+     * `allDfs(includeGroups = false) -> `[colsAtAnyDepth][org.jetbrains.kotlinx.dataframe.api.ColsAtAnyDepthColumnsSelectionDsl.colsAtAnyDepth]` { includeGroups || !it.`[isColumnGroup][org.jetbrains.kotlinx.dataframe.DataColumn.isColumnGroup]`() }`
+     *
+     * `dfsOf<Type> { condition } -> `[colsAtAnyDepth][org.jetbrains.kotlinx.dataframe.api.ColsAtAnyDepthColumnsSelectionDsl.colsAtAnyDepth]`().`[colsOf][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<Type> { condition }`
+     *
+     * [cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]` { condition }.`[recursively][recursively]`() -> `[colsAtAnyDepth][org.jetbrains.kotlinx.dataframe.api.ColsAtAnyDepthColumnsSelectionDsl.colsAtAnyDepth]` { condition }`
+     *
+     * [first][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.first]` { condition }.`[rec][rec]`() -> `[colsAtAnyDepth][org.jetbrains.kotlinx.dataframe.api.ColsAtAnyDepthColumnsSelectionDsl.colsAtAnyDepth]` { condition }.`[first][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.first]`()`
+     *
+     * [all][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.all]`().`[recursively][recursively]`() -> `[colsAtAnyDepth][org.jetbrains.kotlinx.dataframe.api.ColsAtAnyDepthColumnsSelectionDsl.colsAtAnyDepth]`()`
+     *
+     * @see [DataFrame.flatten]
+     * @see [ColumnsSelectionDsl.simplify]
+     */
+    public fun SingleColumn<DataRow<*>>.colsAtAnyDepth(predicate: ColumnFilter<*> = { true }): ColumnSet<*> =
+        ensureIsColumnGroup().colsAtAnyDepthInternal(predicate)
+
+    /**
+     * ## Cols At Any Depth
+     *
+     * Returns all columns in [this] at any depth (so also inside [Column Groups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup]) if they satisfy the
+     * optional given predicate.
+     *
+     * This function can also be followed by another [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] filter function like
+     * [colsOf][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf], [single][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.single], or [valueCols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.valueCols].
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColsAtAnyDepthColumnsSelectionDsl.Grammar]
+     * #### For example:
+     * `// Depth-first search to a column containing the value "Alice"`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsAtAnyDepth][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsAtAnyDepth]`().`[first][org.jetbrains.kotlinx.dataframe.api.FirstColumnsSelectionDsl.firstCol]`  { "Alice"  `[in][Iterable.contains]` it.`[values][org.jetbrains.kotlinx.dataframe.DataColumn.values]`() } }`
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * `// The columns at any depth excluding the top-level`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroups][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroups]`().`[colsAtAnyDepth][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.colsAtAnyDepth]`() }`
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * `// All value- and frame columns at any depth`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsAtAnyDepth][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsAtAnyDepth]` { !it.`[isColumnGroup][org.jetbrains.kotlinx.dataframe.DataColumn.isColumnGroup]` } }`
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * `// All value columns at any depth nested under a column group named "myColGroup"`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColGroup.`[colsAtAnyDepth][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.colsAtAnyDepth]`().`[valueCols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.valueCols]`() }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][DataFrame.select]` { "myColumnGroup".`[colsAtAnyDepth][String.colsAtAnyDepth]`  { "Alice"  `[in][Iterable.contains]` it.`[values][DataColumn.values]`() } }`
+     *
+     * #### Converting from deprecated syntax:
+     *
+     * `dfs  { condition } -> `[colsAtAnyDepth][org.jetbrains.kotlinx.dataframe.api.ColsAtAnyDepthColumnsSelectionDsl.colsAtAnyDepth]` { condition }`
+     *
+     * `allDfs(includeGroups = false) -> `[colsAtAnyDepth][org.jetbrains.kotlinx.dataframe.api.ColsAtAnyDepthColumnsSelectionDsl.colsAtAnyDepth]` { includeGroups || !it.`[isColumnGroup][org.jetbrains.kotlinx.dataframe.DataColumn.isColumnGroup]`() }`
+     *
+     * `dfsOf<Type> { condition } -> `[colsAtAnyDepth][org.jetbrains.kotlinx.dataframe.api.ColsAtAnyDepthColumnsSelectionDsl.colsAtAnyDepth]`().`[colsOf][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<Type> { condition }`
+     *
+     * [cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]` { condition }.`[recursively][recursively]`() -> `[colsAtAnyDepth][org.jetbrains.kotlinx.dataframe.api.ColsAtAnyDepthColumnsSelectionDsl.colsAtAnyDepth]` { condition }`
+     *
+     * [first][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.first]` { condition }.`[rec][rec]`() -> `[colsAtAnyDepth][org.jetbrains.kotlinx.dataframe.api.ColsAtAnyDepthColumnsSelectionDsl.colsAtAnyDepth]` { condition }.`[first][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.first]`()`
+     *
+     * [all][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.all]`().`[recursively][recursively]`() -> `[colsAtAnyDepth][org.jetbrains.kotlinx.dataframe.api.ColsAtAnyDepthColumnsSelectionDsl.colsAtAnyDepth]`()`
+     *
+     * @see [DataFrame.flatten]
+     * @see [ColumnsSelectionDsl.simplify]
+     */
+    public fun String.colsAtAnyDepth(predicate: ColumnFilter<*> = { true }): ColumnSet<*> =
+        columnGroup(this).colsAtAnyDepth(predicate)
+
+    /**
+     * ## Cols At Any Depth
+     *
+     * Returns all columns in [this] at any depth (so also inside [Column Groups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup]) if they satisfy the
+     * optional given predicate.
+     *
+     * This function can also be followed by another [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] filter function like
+     * [colsOf][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf], [single][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.single], or [valueCols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.valueCols].
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColsAtAnyDepthColumnsSelectionDsl.Grammar]
+     * #### For example:
+     * `// Depth-first search to a column containing the value "Alice"`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsAtAnyDepth][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsAtAnyDepth]`().`[first][org.jetbrains.kotlinx.dataframe.api.FirstColumnsSelectionDsl.firstCol]`  { "Alice"  `[in][Iterable.contains]` it.`[values][org.jetbrains.kotlinx.dataframe.DataColumn.values]`() } }`
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * `// The columns at any depth excluding the top-level`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroups][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroups]`().`[colsAtAnyDepth][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.colsAtAnyDepth]`() }`
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * `// All value- and frame columns at any depth`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsAtAnyDepth][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsAtAnyDepth]` { !it.`[isColumnGroup][org.jetbrains.kotlinx.dataframe.DataColumn.isColumnGroup]` } }`
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * `// All value columns at any depth nested under a column group named "myColGroup"`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColGroup.`[colsAtAnyDepth][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.colsAtAnyDepth]`().`[valueCols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.valueCols]`() }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][DataFrame.select]` { Type::myColumnGroup.`[colsAtAnyDepth][KProperty.colsAtAnyDepth]`  { "Alice"  `[in][Iterable.contains]` it.`[values][DataColumn.values]`() } }`
+     *
+     * #### Converting from deprecated syntax:
+     *
+     * `dfs  { condition } -> `[colsAtAnyDepth][org.jetbrains.kotlinx.dataframe.api.ColsAtAnyDepthColumnsSelectionDsl.colsAtAnyDepth]` { condition }`
+     *
+     * `allDfs(includeGroups = false) -> `[colsAtAnyDepth][org.jetbrains.kotlinx.dataframe.api.ColsAtAnyDepthColumnsSelectionDsl.colsAtAnyDepth]` { includeGroups || !it.`[isColumnGroup][org.jetbrains.kotlinx.dataframe.DataColumn.isColumnGroup]`() }`
+     *
+     * `dfsOf<Type> { condition } -> `[colsAtAnyDepth][org.jetbrains.kotlinx.dataframe.api.ColsAtAnyDepthColumnsSelectionDsl.colsAtAnyDepth]`().`[colsOf][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<Type> { condition }`
+     *
+     * [cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]` { condition }.`[recursively][recursively]`() -> `[colsAtAnyDepth][org.jetbrains.kotlinx.dataframe.api.ColsAtAnyDepthColumnsSelectionDsl.colsAtAnyDepth]` { condition }`
+     *
+     * [first][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.first]` { condition }.`[rec][rec]`() -> `[colsAtAnyDepth][org.jetbrains.kotlinx.dataframe.api.ColsAtAnyDepthColumnsSelectionDsl.colsAtAnyDepth]` { condition }.`[first][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.first]`()`
+     *
+     * [all][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.all]`().`[recursively][recursively]`() -> `[colsAtAnyDepth][org.jetbrains.kotlinx.dataframe.api.ColsAtAnyDepthColumnsSelectionDsl.colsAtAnyDepth]`()`
+     *
+     * @see [DataFrame.flatten]
+     * @see [ColumnsSelectionDsl.simplify]
+     */
+    public fun KProperty<*>.colsAtAnyDepth(predicate: ColumnFilter<*> = { true }): ColumnSet<*> =
+        columnGroup(this).colsAtAnyDepth(predicate)
+
+    /**
+     * ## Cols At Any Depth
+     *
+     * Returns all columns in [this] at any depth (so also inside [Column Groups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup]) if they satisfy the
+     * optional given predicate.
+     *
+     * This function can also be followed by another [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] filter function like
+     * [colsOf][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf], [single][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.single], or [valueCols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.valueCols].
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColsAtAnyDepthColumnsSelectionDsl.Grammar]
+     * #### For example:
+     * `// Depth-first search to a column containing the value "Alice"`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsAtAnyDepth][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsAtAnyDepth]`().`[first][org.jetbrains.kotlinx.dataframe.api.FirstColumnsSelectionDsl.firstCol]`  { "Alice"  `[in][Iterable.contains]` it.`[values][org.jetbrains.kotlinx.dataframe.DataColumn.values]`() } }`
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * `// The columns at any depth excluding the top-level`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroups][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroups]`().`[colsAtAnyDepth][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.colsAtAnyDepth]`() }`
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * `// All value- and frame columns at any depth`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsAtAnyDepth][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsAtAnyDepth]` { !it.`[isColumnGroup][org.jetbrains.kotlinx.dataframe.DataColumn.isColumnGroup]` } }`
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * `// All value columns at any depth nested under a column group named "myColGroup"`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColGroup.`[colsAtAnyDepth][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.colsAtAnyDepth]`().`[valueCols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.valueCols]`() }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][DataFrame.select]` { "pathTo"["myGroupCol"].`[colsAtAnyDepth][ColumnsSelectionDsl.colsAtAnyDepth]`  { "Alice"  `[in][Iterable.contains]` it.`[values][DataColumn.values]`() } }`
+     *
+     * #### Converting from deprecated syntax:
+     *
+     * `dfs  { condition } -> `[colsAtAnyDepth][org.jetbrains.kotlinx.dataframe.api.ColsAtAnyDepthColumnsSelectionDsl.colsAtAnyDepth]` { condition }`
+     *
+     * `allDfs(includeGroups = false) -> `[colsAtAnyDepth][org.jetbrains.kotlinx.dataframe.api.ColsAtAnyDepthColumnsSelectionDsl.colsAtAnyDepth]` { includeGroups || !it.`[isColumnGroup][org.jetbrains.kotlinx.dataframe.DataColumn.isColumnGroup]`() }`
+     *
+     * `dfsOf<Type> { condition } -> `[colsAtAnyDepth][org.jetbrains.kotlinx.dataframe.api.ColsAtAnyDepthColumnsSelectionDsl.colsAtAnyDepth]`().`[colsOf][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<Type> { condition }`
+     *
+     * [cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]` { condition }.`[recursively][recursively]`() -> `[colsAtAnyDepth][org.jetbrains.kotlinx.dataframe.api.ColsAtAnyDepthColumnsSelectionDsl.colsAtAnyDepth]` { condition }`
+     *
+     * [first][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.first]` { condition }.`[rec][rec]`() -> `[colsAtAnyDepth][org.jetbrains.kotlinx.dataframe.api.ColsAtAnyDepthColumnsSelectionDsl.colsAtAnyDepth]` { condition }.`[first][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.first]`()`
+     *
+     * [all][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.all]`().`[recursively][recursively]`() -> `[colsAtAnyDepth][org.jetbrains.kotlinx.dataframe.api.ColsAtAnyDepthColumnsSelectionDsl.colsAtAnyDepth]`()`
+     *
+     * @see [DataFrame.flatten]
+     * @see [ColumnsSelectionDsl.simplify]
+     */
+    public fun ColumnPath.colsAtAnyDepth(predicate: ColumnFilter<*> = { true }): ColumnSet<*> =
+        columnGroup(this).colsAtAnyDepth(predicate)
+
+    // endregion
+}
+
+/**
+ * Returns all columns inside this [ColumnsResolver] at any depth if they satisfy the
+ * given predicate.
+ */
+internal fun ColumnsResolver<*>.colsAtAnyDepthInternal(predicate: ColumnFilter<*>): ColumnSet<*> =
+    colsInternal(predicate)
+        .atAnyDepthImpl(includeTopLevel = true, includeGroups = true)
+
+// endregion
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/colsInGroups.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/colsInGroups.kt
new file mode 100644
index 000000000..967f7ccd2
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/colsInGroups.kt
@@ -0,0 +1,463 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import org.jetbrains.kotlinx.dataframe.ColumnFilter
+import org.jetbrains.kotlinx.dataframe.DataColumn
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.DataRow
+import org.jetbrains.kotlinx.dataframe.columns.ColumnGroup
+import org.jetbrains.kotlinx.dataframe.columns.ColumnPath
+import org.jetbrains.kotlinx.dataframe.columns.ColumnSet
+import org.jetbrains.kotlinx.dataframe.columns.ColumnWithPath
+import org.jetbrains.kotlinx.dataframe.columns.SingleColumn
+import org.jetbrains.kotlinx.dataframe.impl.columns.TransformableColumnSet
+import org.jetbrains.kotlinx.dataframe.impl.columns.transform
+import kotlin.reflect.KProperty
+
+// region ColumnsSelectionDsl
+
+/**
+ * ## Cols in Groups [Columns Selection DSL][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl]
+ *
+ * See [Grammar] for all functions in this interface.
+ */
+public interface ColsInGroupsColumnsSelectionDsl {
+
+    /**
+     * ## Cols in Groups Grammar
+     *
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * [(What is this notation?)][org.jetbrains.kotlinx.dataframe.documentation.DslGrammar]
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  ### Definitions:
+     *  `columnSet: `[`ColumnSet`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]`<*>`
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  `columnGroup: `[`SingleColumn`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]`<`[`DataRow`][org.jetbrains.kotlinx.dataframe.DataRow]`<*>> | `[`String`][String]`  |  `[`KProperty`][kotlin.reflect.KProperty]`<* | `[`DataRow`][org.jetbrains.kotlinx.dataframe.DataRow]`<*>> | `[`ColumnPath`][org.jetbrains.kotlinx.dataframe.columns.ColumnPath]
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  `condition: `[`ColumnFilter`][org.jetbrains.kotlinx.dataframe.ColumnFilter]
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  ### What can be called directly in the [Columns Selection DSL][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl]:
+     *
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  [**`colsInGroups`**][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsInGroups]`  [  `**`{ `**[`condition`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ConditionDef]**` }`**` ]`
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  ### What can be called on a [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]:
+     *
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  [`columnSet`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ColumnSetDef]
+     *
+     *  &nbsp;&nbsp;&nbsp;&nbsp;__`.`__[**`colsInGroups`**][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsInGroups]`  [  `**`{ `**[`condition`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ConditionDef]**` }`**` ]`
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  ### What can be called on a [Column Group (reference)][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ColumnGroupDef]:
+     *
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  [`columnGroup`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ColumnGroupDef]
+     *
+     *  &nbsp;&nbsp;&nbsp;&nbsp;__`.`__[**`colsInGroups`**][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsInGroups]`  [  `**`{ `**[`condition`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ConditionDef]**` }`**` ]`
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     */
+    public interface Grammar {
+
+        /** [**`colsInGroups`**][ColumnsSelectionDsl.colsInGroups] */
+        public interface PlainDslName
+
+        /** __`.`__[**`colsInGroups`**][ColumnsSelectionDsl.colsInGroups] */
+        public interface ColumnSetName
+
+        /** __`.`__[**`colsInGroups`**][ColumnsSelectionDsl.colsInGroups] */
+        public interface ColumnGroupName
+    }
+
+    /**
+     * ## Cols in Groups
+     *
+     * [colsInGroups][colsInGroups] is a function that returns all (optionally filtered) columns at the top-levels of
+     * all [column groups][ColumnGroup] in [this]. This is useful if you want to select all columns that are
+     * "one level deeper".
+     *
+     * NOTE: This function should not be confused with [cols][ColumnsSelectionDsl.cols], which operates on all
+     * columns directly in [this], or with [colsAtAnyDepth][ColumnsSelectionDsl.colsAtAnyDepth], which operates on all
+     * columns in [this] at any depth.
+     *
+     * ### Check out: [Grammar]
+     *
+     * #### For example:
+     *
+     * To get only the columns inside all column groups in a [DataFrame], instead of having to write:
+     *
+     * `df.`[select][DataFrame.select]` { colGroupA.`[cols][ColumnsSelectionDsl.cols]`() `[and][ColumnsSelectionDsl.and]` colGroupB.`[cols][ColumnsSelectionDsl.cols]`() ...  }`
+     *
+     * you can use:
+     *
+     * `df.`[select][DataFrame.select]`  {  `[colsInGroups][ColumnsSelectionDsl.colsInGroups]`() }`
+     *
+     * and
+     *
+     * `df.`[select][DataFrame.select]`  {  `[colsInGroups][ColumnsSelectionDsl.colsInGroups]`  { "user"  `[in][String.contains]` it.`[name][DataColumn.name]` } }`
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * Similarly, you can take the columns inside all [column groups][ColumnGroup] in a [ColumnSet]:
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * `df.`[select][DataFrame.select]`  {  `[colGroups][ColumnsSelectionDsl.colGroups]`  { "my"  `[in][String.contains]` it.`[name][DataColumn.name]` }.`[colsInGroups][ColumnSet.colsInGroups]`() }`
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     * #### Examples of this overload:
+     *
+     *
+     *
+     * @see [ColumnsSelectionDsl.cols]
+     * @see [ColumnsSelectionDsl.colGroups]
+     * @param [predicate] An optional predicate to filter the cols by.
+     * @return A [TransformableColumnSet] containing the (filtered) cols.
+     */
+    private interface ColsInGroupsDocs {
+
+        /** Example argument to use */
+        interface ExampleArg
+    }
+
+    /**
+     * ## Cols in Groups
+     *
+     * [colsInGroups][org.jetbrains.kotlinx.dataframe.api.ColsInGroupsColumnsSelectionDsl.colsInGroups] is a function that returns all (optionally filtered) columns at the top-levels of
+     * all [column groups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup] in [this]. This is useful if you want to select all columns that are
+     * "one level deeper".
+     *
+     * NOTE: This function should not be confused with [cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols], which operates on all
+     * columns directly in [this], or with [colsAtAnyDepth][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsAtAnyDepth], which operates on all
+     * columns in [this] at any depth.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColsInGroupsColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * To get only the columns inside all column groups in a [DataFrame][org.jetbrains.kotlinx.dataframe.DataFrame], instead of having to write:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { colGroupA.`[cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`() `[and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]` colGroupB.`[cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`() ...  }`
+     *
+     * you can use:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsInGroups][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsInGroups]`() }`
+     *
+     * and
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsInGroups][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsInGroups]`  { "user"  `[in][String.contains]` it.`[name][org.jetbrains.kotlinx.dataframe.DataColumn.name]` } }`
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * Similarly, you can take the columns inside all [column groups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup] in a [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]:
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroups][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroups]`  { "my"  `[in][String.contains]` it.`[name][org.jetbrains.kotlinx.dataframe.DataColumn.name]` }.`[colsInGroups][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.colsInGroups]`() }`
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     * #### Examples of this overload:
+     *
+     * `df.`[select][DataFrame.select]`  {  `[cols][ColumnsSelectionDsl.cols]` { .. }.`[colsInGroups][ColumnSet.colsInGroups]`  { "my"  `[in][String.contains]` it.`[name][DataColumn.name]` } }`
+     *
+     * `df.`[select][DataFrame.select]`  {  `[colsOf][ColumnsSelectionDsl.colsOf]`<`[DataRow][DataRow]`<MyGroupType>>().`[colsInGroups][ColumnSet.colsInGroups]`() }`
+     *
+     * @see [ColumnsSelectionDsl.cols]
+     * @see [ColumnsSelectionDsl.colGroups]
+     * @param [predicate] An optional predicate to filter the cols by.
+     * @return A [TransformableColumnSet][org.jetbrains.kotlinx.dataframe.impl.columns.TransformableColumnSet] containing the (filtered) cols.
+     */
+    public fun ColumnSet<*>.colsInGroups(predicate: ColumnFilter<*> = { true }): TransformableColumnSet<*> =
+        transform { it.flatMap { it.cols().filter { predicate(it) } } }
+
+    /**
+     * ## Cols in Groups
+     *
+     * [colsInGroups][org.jetbrains.kotlinx.dataframe.api.ColsInGroupsColumnsSelectionDsl.colsInGroups] is a function that returns all (optionally filtered) columns at the top-levels of
+     * all [column groups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup] in [this]. This is useful if you want to select all columns that are
+     * "one level deeper".
+     *
+     * NOTE: This function should not be confused with [cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols], which operates on all
+     * columns directly in [this], or with [colsAtAnyDepth][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsAtAnyDepth], which operates on all
+     * columns in [this] at any depth.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColsInGroupsColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * To get only the columns inside all column groups in a [DataFrame][org.jetbrains.kotlinx.dataframe.DataFrame], instead of having to write:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { colGroupA.`[cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`() `[and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]` colGroupB.`[cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`() ...  }`
+     *
+     * you can use:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsInGroups][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsInGroups]`() }`
+     *
+     * and
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsInGroups][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsInGroups]`  { "user"  `[in][String.contains]` it.`[name][org.jetbrains.kotlinx.dataframe.DataColumn.name]` } }`
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * Similarly, you can take the columns inside all [column groups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup] in a [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]:
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroups][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroups]`  { "my"  `[in][String.contains]` it.`[name][org.jetbrains.kotlinx.dataframe.DataColumn.name]` }.`[colsInGroups][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.colsInGroups]`() }`
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     * #### Examples of this overload:
+     *
+     * `df.`[select][DataFrame.select]`  {  `[colsInGroups][ColumnSet.colsInGroups]`  { "my"  `[in][String.contains]` it.`[name][DataColumn.name]` } }`
+     *
+     * `df.`[select][DataFrame.select]`  {  `[colsInGroups][ColumnSet.colsInGroups]`() }`
+     *
+     * @see [ColumnsSelectionDsl.cols]
+     * @see [ColumnsSelectionDsl.colGroups]
+     * @param [predicate] An optional predicate to filter the cols by.
+     * @return A [TransformableColumnSet][org.jetbrains.kotlinx.dataframe.impl.columns.TransformableColumnSet] containing the (filtered) cols.
+     */
+    public fun ColumnsSelectionDsl<*>.colsInGroups(predicate: ColumnFilter<*> = { true }): TransformableColumnSet<*> =
+        asSingleColumn().colsInGroups(predicate)
+
+    /**
+     * ## Cols in Groups
+     *
+     * [colsInGroups][org.jetbrains.kotlinx.dataframe.api.ColsInGroupsColumnsSelectionDsl.colsInGroups] is a function that returns all (optionally filtered) columns at the top-levels of
+     * all [column groups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup] in [this]. This is useful if you want to select all columns that are
+     * "one level deeper".
+     *
+     * NOTE: This function should not be confused with [cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols], which operates on all
+     * columns directly in [this], or with [colsAtAnyDepth][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsAtAnyDepth], which operates on all
+     * columns in [this] at any depth.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColsInGroupsColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * To get only the columns inside all column groups in a [DataFrame][org.jetbrains.kotlinx.dataframe.DataFrame], instead of having to write:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { colGroupA.`[cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`() `[and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]` colGroupB.`[cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`() ...  }`
+     *
+     * you can use:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsInGroups][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsInGroups]`() }`
+     *
+     * and
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsInGroups][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsInGroups]`  { "user"  `[in][String.contains]` it.`[name][org.jetbrains.kotlinx.dataframe.DataColumn.name]` } }`
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * Similarly, you can take the columns inside all [column groups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup] in a [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]:
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroups][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroups]`  { "my"  `[in][String.contains]` it.`[name][org.jetbrains.kotlinx.dataframe.DataColumn.name]` }.`[colsInGroups][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.colsInGroups]`() }`
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     * #### Examples of this overload:
+     *
+     * `df.`[select][DataFrame.select]` { myColumnGroup.`[colsInGroups][SingleColumn.colsInGroups]`() }`
+     *
+     * `df.`[select][DataFrame.select]` { myColumnGroup.`[colsInGroups][SingleColumn.colsInGroups]` { it.`[any][ColumnWithPath.any]` { it == "Alice" } } }`
+     *
+     * @see [ColumnsSelectionDsl.cols]
+     * @see [ColumnsSelectionDsl.colGroups]
+     * @param [predicate] An optional predicate to filter the cols by.
+     * @return A [TransformableColumnSet][org.jetbrains.kotlinx.dataframe.impl.columns.TransformableColumnSet] containing the (filtered) cols.
+     */
+    public fun SingleColumn<DataRow<*>>.colsInGroups(predicate: ColumnFilter<*> = { true }): TransformableColumnSet<*> =
+        ensureIsColumnGroup().allColumnsInternal().colsInGroups(predicate)
+
+    /**
+     * ## Cols in Groups
+     *
+     * [colsInGroups][org.jetbrains.kotlinx.dataframe.api.ColsInGroupsColumnsSelectionDsl.colsInGroups] is a function that returns all (optionally filtered) columns at the top-levels of
+     * all [column groups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup] in [this]. This is useful if you want to select all columns that are
+     * "one level deeper".
+     *
+     * NOTE: This function should not be confused with [cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols], which operates on all
+     * columns directly in [this], or with [colsAtAnyDepth][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsAtAnyDepth], which operates on all
+     * columns in [this] at any depth.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColsInGroupsColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * To get only the columns inside all column groups in a [DataFrame][org.jetbrains.kotlinx.dataframe.DataFrame], instead of having to write:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { colGroupA.`[cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`() `[and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]` colGroupB.`[cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`() ...  }`
+     *
+     * you can use:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsInGroups][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsInGroups]`() }`
+     *
+     * and
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsInGroups][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsInGroups]`  { "user"  `[in][String.contains]` it.`[name][org.jetbrains.kotlinx.dataframe.DataColumn.name]` } }`
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * Similarly, you can take the columns inside all [column groups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup] in a [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]:
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroups][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroups]`  { "my"  `[in][String.contains]` it.`[name][org.jetbrains.kotlinx.dataframe.DataColumn.name]` }.`[colsInGroups][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.colsInGroups]`() }`
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     * #### Examples of this overload:
+     *
+     * `df.`[select][DataFrame.select]` { "myColumnGroup".`[colsInGroups][String.colsInGroups]`() }`
+     *
+     * @see [ColumnsSelectionDsl.cols]
+     * @see [ColumnsSelectionDsl.colGroups]
+     * @param [predicate] An optional predicate to filter the cols by.
+     * @return A [TransformableColumnSet][org.jetbrains.kotlinx.dataframe.impl.columns.TransformableColumnSet] containing the (filtered) cols.
+     */
+    public fun String.colsInGroups(predicate: ColumnFilter<*> = { true }): TransformableColumnSet<*> =
+        columnGroup(this).colsInGroups(predicate)
+
+    /**
+     * ## Cols in Groups
+     *
+     * [colsInGroups][org.jetbrains.kotlinx.dataframe.api.ColsInGroupsColumnsSelectionDsl.colsInGroups] is a function that returns all (optionally filtered) columns at the top-levels of
+     * all [column groups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup] in [this]. This is useful if you want to select all columns that are
+     * "one level deeper".
+     *
+     * NOTE: This function should not be confused with [cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols], which operates on all
+     * columns directly in [this], or with [colsAtAnyDepth][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsAtAnyDepth], which operates on all
+     * columns in [this] at any depth.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColsInGroupsColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * To get only the columns inside all column groups in a [DataFrame][org.jetbrains.kotlinx.dataframe.DataFrame], instead of having to write:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { colGroupA.`[cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`() `[and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]` colGroupB.`[cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`() ...  }`
+     *
+     * you can use:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsInGroups][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsInGroups]`() }`
+     *
+     * and
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsInGroups][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsInGroups]`  { "user"  `[in][String.contains]` it.`[name][org.jetbrains.kotlinx.dataframe.DataColumn.name]` } }`
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * Similarly, you can take the columns inside all [column groups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup] in a [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]:
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroups][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroups]`  { "my"  `[in][String.contains]` it.`[name][org.jetbrains.kotlinx.dataframe.DataColumn.name]` }.`[colsInGroups][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.colsInGroups]`() }`
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     * #### Examples of this overload:
+     *
+     * `df.`[select][DataFrame.select]` { Type::myColumnGroup.`[colsInGroups][KProperty.colsInGroups]`() }`
+     *
+     * `df.`[select][DataFrame.select]` { DataSchemaType::myColumnGroup.`[colsInGroups][KProperty.colsInGroups]`() }`
+     *
+     * @see [ColumnsSelectionDsl.cols]
+     * @see [ColumnsSelectionDsl.colGroups]
+     * @param [predicate] An optional predicate to filter the cols by.
+     * @return A [TransformableColumnSet][org.jetbrains.kotlinx.dataframe.impl.columns.TransformableColumnSet] containing the (filtered) cols.
+     */
+    public fun KProperty<*>.colsInGroups(predicate: ColumnFilter<*> = { true }): TransformableColumnSet<*> =
+        columnGroup(this).colsInGroups(predicate)
+
+    /**
+     * ## Cols in Groups
+     *
+     * [colsInGroups][org.jetbrains.kotlinx.dataframe.api.ColsInGroupsColumnsSelectionDsl.colsInGroups] is a function that returns all (optionally filtered) columns at the top-levels of
+     * all [column groups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup] in [this]. This is useful if you want to select all columns that are
+     * "one level deeper".
+     *
+     * NOTE: This function should not be confused with [cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols], which operates on all
+     * columns directly in [this], or with [colsAtAnyDepth][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsAtAnyDepth], which operates on all
+     * columns in [this] at any depth.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColsInGroupsColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * To get only the columns inside all column groups in a [DataFrame][org.jetbrains.kotlinx.dataframe.DataFrame], instead of having to write:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { colGroupA.`[cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`() `[and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]` colGroupB.`[cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`() ...  }`
+     *
+     * you can use:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsInGroups][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsInGroups]`() }`
+     *
+     * and
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsInGroups][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsInGroups]`  { "user"  `[in][String.contains]` it.`[name][org.jetbrains.kotlinx.dataframe.DataColumn.name]` } }`
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * Similarly, you can take the columns inside all [column groups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup] in a [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]:
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colGroups][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroups]`  { "my"  `[in][String.contains]` it.`[name][org.jetbrains.kotlinx.dataframe.DataColumn.name]` }.`[colsInGroups][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.colsInGroups]`() }`
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     * #### Examples of this overload:
+     *
+     * `df.`[select][DataFrame.select]` { "pathTo"["myColumnGroup"].`[colsInGroups][ColumnPath.colsInGroups]`() }`
+     *
+     * @see [ColumnsSelectionDsl.cols]
+     * @see [ColumnsSelectionDsl.colGroups]
+     * @param [predicate] An optional predicate to filter the cols by.
+     * @return A [TransformableColumnSet][org.jetbrains.kotlinx.dataframe.impl.columns.TransformableColumnSet] containing the (filtered) cols.
+     */
+    public fun ColumnPath.colsInGroups(predicate: ColumnFilter<*> = { true }): TransformableColumnSet<*> =
+        columnGroup(this).colsInGroups(predicate)
+}
+
+// endregion
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/colsOf.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/colsOf.kt
new file mode 100644
index 000000000..ae8ccbe68
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/colsOf.kt
@@ -0,0 +1,641 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import org.jetbrains.kotlinx.dataframe.ColumnFilter
+import org.jetbrains.kotlinx.dataframe.DataColumn
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.DataRow
+import org.jetbrains.kotlinx.dataframe.annotations.Interpretable
+import org.jetbrains.kotlinx.dataframe.api.ColsOfColumnsSelectionDsl.Grammar
+import org.jetbrains.kotlinx.dataframe.columns.ColumnPath
+import org.jetbrains.kotlinx.dataframe.columns.ColumnSet
+import org.jetbrains.kotlinx.dataframe.columns.ColumnsResolver
+import org.jetbrains.kotlinx.dataframe.columns.SingleColumn
+import org.jetbrains.kotlinx.dataframe.columns.size
+import org.jetbrains.kotlinx.dataframe.impl.columns.TransformableColumnSet
+import kotlin.reflect.KProperty
+import kotlin.reflect.KType
+import kotlin.reflect.typeOf
+
+// region ColumnsSelectionDsl
+
+/**
+ * ## Cols Of [Columns Selection DSL][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl]
+ *
+ * See [Grammar] for all functions in this interface.
+ */
+public interface ColsOfColumnsSelectionDsl {
+
+    /**
+     * ## Cols Of Grammar
+     *
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * [(What is this notation?)][org.jetbrains.kotlinx.dataframe.documentation.DslGrammar]
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  ### Definitions:
+     *  `columnSet: `[`ColumnSet`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]`<*>`
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  `singleColumn: `[`SingleColumn`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]`<`[`DataRow`][org.jetbrains.kotlinx.dataframe.DataRow]`<*>>`
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  `columnGroupReference: `[`String`][String]`  |  `[`KProperty`][kotlin.reflect.KProperty]`<*> | `[`ColumnPath`][org.jetbrains.kotlinx.dataframe.columns.ColumnPath]
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  `column: `[`ColumnAccessor`][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor]`  |  `[`String`][String]`  | `[`KProperty`][kotlin.reflect.KProperty]`<*> | `[`ColumnPath`][org.jetbrains.kotlinx.dataframe.columns.ColumnPath]
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  `condition: `[`ColumnFilter`][org.jetbrains.kotlinx.dataframe.ColumnFilter]
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  `T: Column type`
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  `kType: `[`KType`][kotlin.reflect.KType]
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  ### What can be called directly in the [Columns Selection DSL][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl]:
+     *
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  [**colsOf**][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]**`<`**[`T`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ColumnTypeDef]**`>`**`  [  `**`(`**[`kType`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.KTypeDef]**`)`**`  ] [  `**`{ `**[`condition`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ConditionDef]**` }`**` ]`
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  ### What can be called on a [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]:
+     *
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  [`columnSet`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ColumnSetDef]
+     *
+     *  &nbsp;&nbsp;&nbsp;&nbsp;__`.`__[**`colsOf`**][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]**`<`**[`T`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ColumnTypeDef]**`>`**`  [  `**`(`**[`kType`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.KTypeDef]**`)`**`  ] [  `**`{ `**[`condition`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ConditionDef]**` }`**` ]`
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  ### On a column group reference:
+     *
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     *  [`singleColumn`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.SingleColumnDef]
+     *
+     *  &nbsp;&nbsp;&nbsp;&nbsp;__`.`__[**`colsOf`**][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]**`<`**[`T`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ColumnTypeDef]**`>`**`  [  `**`(`**[`kType`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.KTypeDef]**`)`**`  ] [  `**`{ `**[`condition`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ConditionDef]**` }`**` ]`
+     *
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     *  [`columnGroupReference`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ColumnGroupNoSingleColumnDef]
+     *
+     *  &nbsp;&nbsp;&nbsp;&nbsp;__`.`__[**`colsOf`**][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]**`<`**[`T`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ColumnTypeDef]**`>(`**[`kType`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.KTypeDef]**`)`**`  [  `**`{ `**[`condition`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ConditionDef]**` }`**` ]`
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     */
+    public interface Grammar {
+
+        /** [**colsOf**][ColumnsSelectionDsl.colsOf] */
+        public interface PlainDslName
+
+        /** __`.`__[**`colsOf`**][ColumnsSelectionDsl.colsOf] */
+        public interface ColumnSetName
+
+        /** __`.`__[**`colsOf`**][ColumnsSelectionDsl.colsOf] */
+        public interface ColumnGroupName
+    }
+
+    /**
+     * ## Cols Of
+     *
+     * Returns a [ColumnSet] of columns from [this] that are a subtype of the given type [C], optionally filtered
+     * by [filter].
+     *
+     * This function operates solely on columns at the top-level.
+     *
+     * ### Check out: [Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][DataFrame.select]`  {  `[colsOf][ColumnsSelectionDsl.colsOf]`<`[Int][Int]`>() }`
+     *
+     * `df.`[select][DataFrame.select]`  {  `[colsOf][ColumnsSelectionDsl.colsOf]`<`[Int][Int]`> { it.`[size][DataColumn.size]` > 10 } }`
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * Alternatively, [colsOf] can also be called on existing columns:
+     *
+     * `df.`[select][DataFrame.select]` { myColumnGroup.`[colsOf][SingleColumn.colsOf]`<`[Int][Int]`>() }`
+     *
+     * `df.`[select][DataFrame.select]` { "myColumnGroup"<Type>().`[colsOf][SingleColumn.colsOf]`<`[Int][Int]`> { it.`[size][DataColumn.size]` > 10 } }`
+     *
+     * `df.`[select][DataFrame.select]` { Type::myColumnGroup.`[colsOf][ColumnsSelectionDsl.colsOf]`<`[Double][Double]`>() }`
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * Finally, [colsOf] can also take a [KType] argument instead of a reified type.
+     * This is useful when the type is not known at compile time or when the API function cannot be inlined.
+     *
+     *
+     * `df.`[select][DataFrame.select]`  {  `[colsOf][ColumnsSelectionDsl.colsOf]`<`[Int][Int]`>(`[typeOf][typeOf]`<`[Int][Int]`>()) }`
+     *
+     * `df.`[select][DataFrame.select]` { "myColumnGroup".`[colsOf][ColumnsSelectionDsl.colsOf]`<`[Int][Int]`>(`[typeOf][typeOf]`<`[Int][Int]`>()) { it: `[DataColumn][DataColumn]`<`[Int][Int]`> -> it.`[size][DataColumn.size]` > 10 } }`
+     *
+     * #### Examples for this overload:
+     */
+    private interface CommonColsOfDocs {
+
+        /** @return A [ColumnSet] containing the columns of given type that were included by [filter]. */
+        interface Return
+
+        /** @param [filter] an optional filter function that takes a column of type [C] and returns `true` if the column should be included. */
+        interface FilterParam
+    }
+
+    /**
+     * ## Cols Of
+     *
+     * Returns a [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] of columns from [this] that are a subtype of the given type [C], optionally filtered
+     * by [filter].
+     *
+     * This function operates solely on columns at the top-level.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColsOfColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsOf][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[Int][Int]`>() }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsOf][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[Int][Int]`> { it.`[size][org.jetbrains.kotlinx.dataframe.DataColumn.size]` > 10 } }`
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * Alternatively, [colsOf][org.jetbrains.kotlinx.dataframe.api.ColsOfColumnsSelectionDsl.colsOf] can also be called on existing columns:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[colsOf][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.colsOf]`<`[Int][Int]`>() }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "myColumnGroup"<Type>().`[colsOf][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.colsOf]`<`[Int][Int]`> { it.`[size][org.jetbrains.kotlinx.dataframe.DataColumn.size]` > 10 } }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { Type::myColumnGroup.`[colsOf][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[Double][Double]`>() }`
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * Finally, [colsOf][org.jetbrains.kotlinx.dataframe.api.ColsOfColumnsSelectionDsl.colsOf] can also take a [KType] argument instead of a reified type.
+     * This is useful when the type is not known at compile time or when the API function cannot be inlined.
+     *
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsOf][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[Int][Int]`>(`[typeOf][typeOf]`<`[Int][Int]`>()) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "myColumnGroup".`[colsOf][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[Int][Int]`>(`[typeOf][typeOf]`<`[Int][Int]`>()) { it: `[DataColumn][org.jetbrains.kotlinx.dataframe.DataColumn]`<`[Int][Int]`> -> it.`[size][org.jetbrains.kotlinx.dataframe.DataColumn.size]` > 10 } }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][DataFrame.select]` { "myColumnGroup".`[colsOf][String.colsOf]`(`[typeOf][typeOf]`<`[Int][Int]`>()) }`
+     *
+     * `df.`[select][DataFrame.select]` { "myColumnGroup".`[colsOf][String.colsOf]`(`[typeOf][typeOf]`<`[Int][Int]`>()) { it: `[DataColumn][DataColumn]`<`[Int][Int]`> -> it.`[size][DataColumn.size]` > 10 } }`
+     *
+     * @param [filter] an optional filter function that takes a column of type [C] and returns `true` if the column should be included.
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing the columns of given type that were included by [filter].
+     */
+    public fun <C> String.colsOf(type: KType, filter: ColumnFilter<C> = { true }): ColumnSet<*> =
+        columnGroup(this).colsOf(type, filter)
+
+    /**
+     * ## Cols Of
+     *
+     * Returns a [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] of columns from [this] that are a subtype of the given type [C], optionally filtered
+     * by [filter].
+     *
+     * This function operates solely on columns at the top-level.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColsOfColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsOf][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[Int][Int]`>() }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsOf][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[Int][Int]`> { it.`[size][org.jetbrains.kotlinx.dataframe.DataColumn.size]` > 10 } }`
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * Alternatively, [colsOf][org.jetbrains.kotlinx.dataframe.api.ColsOfColumnsSelectionDsl.colsOf] can also be called on existing columns:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[colsOf][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.colsOf]`<`[Int][Int]`>() }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "myColumnGroup"<Type>().`[colsOf][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.colsOf]`<`[Int][Int]`> { it.`[size][org.jetbrains.kotlinx.dataframe.DataColumn.size]` > 10 } }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { Type::myColumnGroup.`[colsOf][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[Double][Double]`>() }`
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * Finally, [colsOf][org.jetbrains.kotlinx.dataframe.api.ColsOfColumnsSelectionDsl.colsOf] can also take a [KType] argument instead of a reified type.
+     * This is useful when the type is not known at compile time or when the API function cannot be inlined.
+     *
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsOf][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[Int][Int]`>(`[typeOf][typeOf]`<`[Int][Int]`>()) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "myColumnGroup".`[colsOf][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[Int][Int]`>(`[typeOf][typeOf]`<`[Int][Int]`>()) { it: `[DataColumn][org.jetbrains.kotlinx.dataframe.DataColumn]`<`[Int][Int]`> -> it.`[size][org.jetbrains.kotlinx.dataframe.DataColumn.size]` > 10 } }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][DataFrame.select]` { DataSchemaType::myColumnGroup.`[colsOf][KProperty.colsOf]`(`[typeOf][typeOf]`<`[Int][Int]`>()) }`
+     *
+     * `df.`[select][DataFrame.select]` { Type::myColumnGroup.`[colsOf][KProperty.colsOf]`(`[typeOf][typeOf]`<`[Int][Int]`>()) { it: `[DataColumn][DataColumn]`<`[Int][Int]`> -> it.`[size][DataColumn.size]` > 10 } }`
+     *
+     * @param [filter] an optional filter function that takes a column of type [C] and returns `true` if the column should be included.
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing the columns of given type that were included by [filter].
+     */
+    public fun <C> KProperty<*>.colsOf(type: KType, filter: ColumnFilter<C> = { true }): ColumnSet<*> =
+        columnGroup(this).colsOf(type, filter)
+
+    /**
+     * ## Cols Of
+     *
+     * Returns a [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] of columns from [this] that are a subtype of the given type [C], optionally filtered
+     * by [filter].
+     *
+     * This function operates solely on columns at the top-level.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColsOfColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsOf][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[Int][Int]`>() }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsOf][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[Int][Int]`> { it.`[size][org.jetbrains.kotlinx.dataframe.DataColumn.size]` > 10 } }`
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * Alternatively, [colsOf][org.jetbrains.kotlinx.dataframe.api.ColsOfColumnsSelectionDsl.colsOf] can also be called on existing columns:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[colsOf][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.colsOf]`<`[Int][Int]`>() }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "myColumnGroup"<Type>().`[colsOf][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.colsOf]`<`[Int][Int]`> { it.`[size][org.jetbrains.kotlinx.dataframe.DataColumn.size]` > 10 } }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { Type::myColumnGroup.`[colsOf][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[Double][Double]`>() }`
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * Finally, [colsOf][org.jetbrains.kotlinx.dataframe.api.ColsOfColumnsSelectionDsl.colsOf] can also take a [KType] argument instead of a reified type.
+     * This is useful when the type is not known at compile time or when the API function cannot be inlined.
+     *
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsOf][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[Int][Int]`>(`[typeOf][typeOf]`<`[Int][Int]`>()) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "myColumnGroup".`[colsOf][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[Int][Int]`>(`[typeOf][typeOf]`<`[Int][Int]`>()) { it: `[DataColumn][org.jetbrains.kotlinx.dataframe.DataColumn]`<`[Int][Int]`> -> it.`[size][org.jetbrains.kotlinx.dataframe.DataColumn.size]` > 10 } }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][DataFrame.select]` { "pathTo"["myColumnGroup"].`[colsOf][ColumnPath.colsOf]`(`[typeOf][typeOf]`<`[Int][Int]`>()) }`
+     *
+     * `df.`[select][DataFrame.select]` { "pathTo"["myColumnGroup"].`[colsOf][ColumnPath.colsOf]`(`[typeOf][typeOf]`<`[Int][Int]`>()) { it: `[DataColumn][DataColumn]`<`[Int][Int]`> -> it.`[size][DataColumn.size]` > 10 } }`
+     *
+     * @param [filter] an optional filter function that takes a column of type [C] and returns `true` if the column should be included.
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing the columns of given type that were included by [filter].
+     */
+    public fun <C> ColumnPath.colsOf(type: KType, filter: ColumnFilter<C> = { true }): ColumnSet<*> =
+        columnGroup(this).colsOf(type, filter)
+}
+
+/**
+ * ## Cols Of
+ *
+ * Returns a [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] of columns from [this] that are a subtype of the given type [C], optionally filtered
+ * by [filter].
+ *
+ * This function operates solely on columns at the top-level.
+ *
+ * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColsOfColumnsSelectionDsl.Grammar]
+ *
+ * #### For example:
+ *
+ * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsOf][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[Int][Int]`>() }`
+ *
+ * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsOf][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[Int][Int]`> { it.`[size][org.jetbrains.kotlinx.dataframe.DataColumn.size]` > 10 } }`
+ *
+ * &nbsp;&nbsp;&nbsp;&nbsp;
+ *
+ * Alternatively, [colsOf][org.jetbrains.kotlinx.dataframe.api.ColsOfColumnsSelectionDsl.colsOf] can also be called on existing columns:
+ *
+ * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[colsOf][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.colsOf]`<`[Int][Int]`>() }`
+ *
+ * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "myColumnGroup"<Type>().`[colsOf][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.colsOf]`<`[Int][Int]`> { it.`[size][org.jetbrains.kotlinx.dataframe.DataColumn.size]` > 10 } }`
+ *
+ * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { Type::myColumnGroup.`[colsOf][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[Double][Double]`>() }`
+ *
+ * &nbsp;&nbsp;&nbsp;&nbsp;
+ *
+ * Finally, [colsOf][org.jetbrains.kotlinx.dataframe.api.ColsOfColumnsSelectionDsl.colsOf] can also take a [KType] argument instead of a reified type.
+ * This is useful when the type is not known at compile time or when the API function cannot be inlined.
+ *
+ *
+ * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsOf][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[Int][Int]`>(`[typeOf][typeOf]`<`[Int][Int]`>()) }`
+ *
+ * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "myColumnGroup".`[colsOf][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[Int][Int]`>(`[typeOf][typeOf]`<`[Int][Int]`>()) { it: `[DataColumn][org.jetbrains.kotlinx.dataframe.DataColumn]`<`[Int][Int]`> -> it.`[size][org.jetbrains.kotlinx.dataframe.DataColumn.size]` > 10 } }`
+ *
+ * #### Examples for this overload:
+ *
+ * `df.`[select][DataFrame.select]`  {  `[cols][ColumnsSelectionDsl.cols]` { .. }.`[colsOf][ColumnSet.colsOf]`(`[typeOf][typeOf]`<`[Int][Int]`>()) }`
+ *
+ * `df.`[select][DataFrame.select]`  {  `[cols][ColumnsSelectionDsl.cols]` { .. }.`[colsOf][ColumnSet.colsOf]`(`[typeOf][typeOf]`<`[Int][Int]`>()) { it: `[DataColumn][DataColumn]`<`[Int][Int]`> -> it.`[size][DataColumn.size]` > 10 } }`
+ *
+ * @param [filter] an optional filter function that takes a column of type [C] and returns `true` if the column should be included.
+ * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing the columns of given type that were included by [filter].
+ */
+public fun <C> ColumnSet<*>.colsOf(type: KType, filter: ColumnFilter<C> = { true }): TransformableColumnSet<C> =
+    colsOfInternal(type, filter)
+
+/**
+ * ## Cols Of
+ *
+ * Returns a [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] of columns from [this] that are a subtype of the given type [C], optionally filtered
+ * by [filter].
+ *
+ * This function operates solely on columns at the top-level.
+ *
+ * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColsOfColumnsSelectionDsl.Grammar]
+ *
+ * #### For example:
+ *
+ * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsOf][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[Int][Int]`>() }`
+ *
+ * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsOf][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[Int][Int]`> { it.`[size][org.jetbrains.kotlinx.dataframe.DataColumn.size]` > 10 } }`
+ *
+ * &nbsp;&nbsp;&nbsp;&nbsp;
+ *
+ * Alternatively, [colsOf][org.jetbrains.kotlinx.dataframe.api.ColsOfColumnsSelectionDsl.colsOf] can also be called on existing columns:
+ *
+ * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[colsOf][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.colsOf]`<`[Int][Int]`>() }`
+ *
+ * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "myColumnGroup"<Type>().`[colsOf][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.colsOf]`<`[Int][Int]`> { it.`[size][org.jetbrains.kotlinx.dataframe.DataColumn.size]` > 10 } }`
+ *
+ * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { Type::myColumnGroup.`[colsOf][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[Double][Double]`>() }`
+ *
+ * &nbsp;&nbsp;&nbsp;&nbsp;
+ *
+ * Finally, [colsOf][org.jetbrains.kotlinx.dataframe.api.ColsOfColumnsSelectionDsl.colsOf] can also take a [KType] argument instead of a reified type.
+ * This is useful when the type is not known at compile time or when the API function cannot be inlined.
+ *
+ *
+ * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsOf][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[Int][Int]`>(`[typeOf][typeOf]`<`[Int][Int]`>()) }`
+ *
+ * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "myColumnGroup".`[colsOf][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[Int][Int]`>(`[typeOf][typeOf]`<`[Int][Int]`>()) { it: `[DataColumn][org.jetbrains.kotlinx.dataframe.DataColumn]`<`[Int][Int]`> -> it.`[size][org.jetbrains.kotlinx.dataframe.DataColumn.size]` > 10 } }`
+ *
+ * #### Examples for this overload:
+ *
+ * `df.`[select][DataFrame.select]`  {  `[cols][ColumnsSelectionDsl.cols]` { .. }.`[colsOf][ColumnSet.colsOf]`<`[Int][Int]`>() }`
+ *
+ * `df.`[select][DataFrame.select]`  {  `[cols][ColumnsSelectionDsl.cols]` { .. }.`[colsOf][ColumnSet.colsOf]`<`[Int][Int]`> { it.`[size][DataColumn.size]` > 10 } }`
+ *
+ * @param [filter] an optional filter function that takes a column of type [C] and returns `true` if the column should be included.
+ * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing the columns of given type that were included by [filter].
+ */
+@Interpretable("ColsOf1")
+public inline fun <reified C> ColumnSet<*>.colsOf(
+    noinline filter: ColumnFilter<C> = { true },
+): TransformableColumnSet<C> = colsOf(typeOf<C>(), filter)
+
+/**
+ * ## Cols Of
+ *
+ * Returns a [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] of columns from [this] that are a subtype of the given type [C], optionally filtered
+ * by [filter].
+ *
+ * This function operates solely on columns at the top-level.
+ *
+ * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColsOfColumnsSelectionDsl.Grammar]
+ *
+ * #### For example:
+ *
+ * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsOf][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[Int][Int]`>() }`
+ *
+ * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsOf][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[Int][Int]`> { it.`[size][org.jetbrains.kotlinx.dataframe.DataColumn.size]` > 10 } }`
+ *
+ * &nbsp;&nbsp;&nbsp;&nbsp;
+ *
+ * Alternatively, [colsOf][org.jetbrains.kotlinx.dataframe.api.ColsOfColumnsSelectionDsl.colsOf] can also be called on existing columns:
+ *
+ * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[colsOf][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.colsOf]`<`[Int][Int]`>() }`
+ *
+ * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "myColumnGroup"<Type>().`[colsOf][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.colsOf]`<`[Int][Int]`> { it.`[size][org.jetbrains.kotlinx.dataframe.DataColumn.size]` > 10 } }`
+ *
+ * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { Type::myColumnGroup.`[colsOf][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[Double][Double]`>() }`
+ *
+ * &nbsp;&nbsp;&nbsp;&nbsp;
+ *
+ * Finally, [colsOf][org.jetbrains.kotlinx.dataframe.api.ColsOfColumnsSelectionDsl.colsOf] can also take a [KType] argument instead of a reified type.
+ * This is useful when the type is not known at compile time or when the API function cannot be inlined.
+ *
+ *
+ * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsOf][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[Int][Int]`>(`[typeOf][typeOf]`<`[Int][Int]`>()) }`
+ *
+ * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "myColumnGroup".`[colsOf][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[Int][Int]`>(`[typeOf][typeOf]`<`[Int][Int]`>()) { it: `[DataColumn][org.jetbrains.kotlinx.dataframe.DataColumn]`<`[Int][Int]`> -> it.`[size][org.jetbrains.kotlinx.dataframe.DataColumn.size]` > 10 } }`
+ *
+ * #### Examples for this overload:
+ *
+ * `df.`[select][DataFrame.select]`  {  `[colsOf][SingleColumn.colsOf]`(`[typeOf][typeOf]`<`[Int][Int]`>()) }`
+ *
+ * @param [filter] an optional filter function that takes a column of type [C] and returns `true` if the column should be included.
+ * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing the columns of given type that were included by [filter].
+ */
+public fun <C> ColumnsSelectionDsl<*>.colsOf(
+    type: KType,
+    filter: ColumnFilter<C> = { true },
+): TransformableColumnSet<C> = asSingleColumn().colsOf(type, filter)
+
+/**
+ * ## Cols Of
+ *
+ * Returns a [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] of columns from [this] that are a subtype of the given type [C], optionally filtered
+ * by [filter].
+ *
+ * This function operates solely on columns at the top-level.
+ *
+ * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColsOfColumnsSelectionDsl.Grammar]
+ *
+ * #### For example:
+ *
+ * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsOf][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[Int][Int]`>() }`
+ *
+ * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsOf][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[Int][Int]`> { it.`[size][org.jetbrains.kotlinx.dataframe.DataColumn.size]` > 10 } }`
+ *
+ * &nbsp;&nbsp;&nbsp;&nbsp;
+ *
+ * Alternatively, [colsOf][org.jetbrains.kotlinx.dataframe.api.ColsOfColumnsSelectionDsl.colsOf] can also be called on existing columns:
+ *
+ * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[colsOf][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.colsOf]`<`[Int][Int]`>() }`
+ *
+ * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "myColumnGroup"<Type>().`[colsOf][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.colsOf]`<`[Int][Int]`> { it.`[size][org.jetbrains.kotlinx.dataframe.DataColumn.size]` > 10 } }`
+ *
+ * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { Type::myColumnGroup.`[colsOf][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[Double][Double]`>() }`
+ *
+ * &nbsp;&nbsp;&nbsp;&nbsp;
+ *
+ * Finally, [colsOf][org.jetbrains.kotlinx.dataframe.api.ColsOfColumnsSelectionDsl.colsOf] can also take a [KType] argument instead of a reified type.
+ * This is useful when the type is not known at compile time or when the API function cannot be inlined.
+ *
+ *
+ * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsOf][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[Int][Int]`>(`[typeOf][typeOf]`<`[Int][Int]`>()) }`
+ *
+ * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "myColumnGroup".`[colsOf][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[Int][Int]`>(`[typeOf][typeOf]`<`[Int][Int]`>()) { it: `[DataColumn][org.jetbrains.kotlinx.dataframe.DataColumn]`<`[Int][Int]`> -> it.`[size][org.jetbrains.kotlinx.dataframe.DataColumn.size]` > 10 } }`
+ *
+ * #### Examples for this overload:
+ *
+ * `df.`[select][DataFrame.select]`  {  `[colsOf][SingleColumn.colsOf]`<`[Int][Int]`>() }`
+ *
+ * @param [filter] an optional filter function that takes a column of type [C] and returns `true` if the column should be included.
+ * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing the columns of given type that were included by [filter].
+ */
+@Interpretable("ColsOf0")
+public inline fun <reified C> ColumnsSelectionDsl<*>.colsOf(
+    noinline filter: ColumnFilter<C> = { true },
+): TransformableColumnSet<C> = asSingleColumn().colsOf(typeOf<C>(), filter)
+
+/**
+ * ## Cols Of
+ *
+ * Returns a [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] of columns from [this] that are a subtype of the given type [C], optionally filtered
+ * by [filter].
+ *
+ * This function operates solely on columns at the top-level.
+ *
+ * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColsOfColumnsSelectionDsl.Grammar]
+ *
+ * #### For example:
+ *
+ * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsOf][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[Int][Int]`>() }`
+ *
+ * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsOf][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[Int][Int]`> { it.`[size][org.jetbrains.kotlinx.dataframe.DataColumn.size]` > 10 } }`
+ *
+ * &nbsp;&nbsp;&nbsp;&nbsp;
+ *
+ * Alternatively, [colsOf][org.jetbrains.kotlinx.dataframe.api.ColsOfColumnsSelectionDsl.colsOf] can also be called on existing columns:
+ *
+ * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[colsOf][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.colsOf]`<`[Int][Int]`>() }`
+ *
+ * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "myColumnGroup"<Type>().`[colsOf][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.colsOf]`<`[Int][Int]`> { it.`[size][org.jetbrains.kotlinx.dataframe.DataColumn.size]` > 10 } }`
+ *
+ * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { Type::myColumnGroup.`[colsOf][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[Double][Double]`>() }`
+ *
+ * &nbsp;&nbsp;&nbsp;&nbsp;
+ *
+ * Finally, [colsOf][org.jetbrains.kotlinx.dataframe.api.ColsOfColumnsSelectionDsl.colsOf] can also take a [KType] argument instead of a reified type.
+ * This is useful when the type is not known at compile time or when the API function cannot be inlined.
+ *
+ *
+ * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsOf][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[Int][Int]`>(`[typeOf][typeOf]`<`[Int][Int]`>()) }`
+ *
+ * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "myColumnGroup".`[colsOf][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[Int][Int]`>(`[typeOf][typeOf]`<`[Int][Int]`>()) { it: `[DataColumn][org.jetbrains.kotlinx.dataframe.DataColumn]`<`[Int][Int]`> -> it.`[size][org.jetbrains.kotlinx.dataframe.DataColumn.size]` > 10 } }`
+ *
+ * #### Examples for this overload:
+ *
+ * `df.`[select][DataFrame.select]` { myColumnGroup.`[colsOf][SingleColumn.colsOf]`<`[Int][Int]`>(`[typeOf][typeOf]`<`[Int][Int]`>()) { it: `[DataColumn][DataColumn]`<`[Int][Int]`> -> it.`[size][DataColumn.size]` > 10 } }`
+ *
+ * `df.`[select][DataFrame.select]` { myColumnGroup.`[colsOf][SingleColumn.colsOf]`<`[Int][Int]`>(`[typeOf][typeOf]`<`[Int][Int]`>()) }`
+ *
+ * @param [filter] an optional filter function that takes a column of type [C] and returns `true` if the column should be included.
+ * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing the columns of given type that were included by [filter].
+ */
+public fun <C> SingleColumn<DataRow<*>>.colsOf(
+    type: KType,
+    filter: ColumnFilter<C> = { true },
+): TransformableColumnSet<C> = ensureIsColumnGroup().colsOfInternal(type, filter)
+
+/**
+ * ## Cols Of
+ *
+ * Returns a [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] of columns from [this] that are a subtype of the given type [C], optionally filtered
+ * by [filter].
+ *
+ * This function operates solely on columns at the top-level.
+ *
+ * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColsOfColumnsSelectionDsl.Grammar]
+ *
+ * #### For example:
+ *
+ * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsOf][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[Int][Int]`>() }`
+ *
+ * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsOf][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[Int][Int]`> { it.`[size][org.jetbrains.kotlinx.dataframe.DataColumn.size]` > 10 } }`
+ *
+ * &nbsp;&nbsp;&nbsp;&nbsp;
+ *
+ * Alternatively, [colsOf][org.jetbrains.kotlinx.dataframe.api.ColsOfColumnsSelectionDsl.colsOf] can also be called on existing columns:
+ *
+ * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[colsOf][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.colsOf]`<`[Int][Int]`>() }`
+ *
+ * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "myColumnGroup"<Type>().`[colsOf][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.colsOf]`<`[Int][Int]`> { it.`[size][org.jetbrains.kotlinx.dataframe.DataColumn.size]` > 10 } }`
+ *
+ * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { Type::myColumnGroup.`[colsOf][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[Double][Double]`>() }`
+ *
+ * &nbsp;&nbsp;&nbsp;&nbsp;
+ *
+ * Finally, [colsOf][org.jetbrains.kotlinx.dataframe.api.ColsOfColumnsSelectionDsl.colsOf] can also take a [KType] argument instead of a reified type.
+ * This is useful when the type is not known at compile time or when the API function cannot be inlined.
+ *
+ *
+ * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsOf][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[Int][Int]`>(`[typeOf][typeOf]`<`[Int][Int]`>()) }`
+ *
+ * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "myColumnGroup".`[colsOf][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[Int][Int]`>(`[typeOf][typeOf]`<`[Int][Int]`>()) { it: `[DataColumn][org.jetbrains.kotlinx.dataframe.DataColumn]`<`[Int][Int]`> -> it.`[size][org.jetbrains.kotlinx.dataframe.DataColumn.size]` > 10 } }`
+ *
+ * #### Examples for this overload:
+ *
+ * `df.`[select][DataFrame.select]` { myColumnGroup.`[colsOf][SingleColumn.colsOf]`<`[Int][Int]`> { it.`[size][DataColumn.size]` > 10 } }`
+ *
+ * `df.`[select][DataFrame.select]` { myColumnGroup.`[colsOf][SingleColumn.colsOf]`<`[Int][Int]`>() }`
+ *
+ * @param [filter] an optional filter function that takes a column of type [C] and returns `true` if the column should be included.
+ * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing the columns of given type that were included by [filter].
+ */
+public inline fun <reified C> SingleColumn<DataRow<*>>.colsOf(
+    noinline filter: ColumnFilter<C> = { true },
+): TransformableColumnSet<C> = colsOf(typeOf<C>(), filter)
+
+/**
+ * If this [ColumnsResolver] is a [SingleColumn], it
+ * returns a new [ColumnSet] containing the columns inside of this [SingleColumn] that
+ * match the given [filter] and are the given [type].
+ *
+ * Else, it returns a new [ColumnSet] containing all columns in this [ColumnsResolver] that
+ * match the given [filter] and are the given [type].
+ */
+@Suppress("UNCHECKED_CAST")
+internal fun <C> ColumnsResolver<*>.colsOfInternal(type: KType, filter: ColumnFilter<C>): TransformableColumnSet<C> =
+    colsInternal {
+        it.isSubtypeOf(type) && filter(it.cast())
+    } as TransformableColumnSet<C>
+
+/* TODO: [Issue: #325, context receiver support](https://github.com/Kotlin/dataframe/issues/325)
+context(ColumnsSelectionDsl)
+public inline fun <reified C> KProperty<*>.colsOf(noinline filter: (DataColumn<C>) -> Boolean = { true }): ColumnSet<*> =
+    colsOf(typeOf<C>(), filter)
+
+context(ColumnsSelectionDsl)
+public inline fun <reified C> String.colsOf(noinline filter: (DataColumn<C>) -> Boolean = { true }): ColumnSet<*> =
+    colsOf(typeOf<C>(), filter)
+
+ */
+
+// endregion
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/colsOfKind.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/colsOfKind.kt
new file mode 100644
index 000000000..6a103d9c2
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/colsOfKind.kt
@@ -0,0 +1,402 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import org.jetbrains.kotlinx.dataframe.ColumnFilter
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.DataRow
+import org.jetbrains.kotlinx.dataframe.columns.ColumnKind
+import org.jetbrains.kotlinx.dataframe.columns.ColumnPath
+import org.jetbrains.kotlinx.dataframe.columns.ColumnReference
+import org.jetbrains.kotlinx.dataframe.columns.ColumnSet
+import org.jetbrains.kotlinx.dataframe.columns.ColumnsResolver
+import org.jetbrains.kotlinx.dataframe.columns.SingleColumn
+import org.jetbrains.kotlinx.dataframe.documentation.AccessApi
+import org.jetbrains.kotlinx.dataframe.impl.columns.TransformableColumnSet
+import org.jetbrains.kotlinx.dataframe.impl.headPlusArray
+import kotlin.reflect.KProperty
+
+// region ColumnsSelectionDsl
+
+/**
+ * ## Cols Of Kind [Columns Selection DSL][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl]
+ *
+ * See [Grammar] for all functions in this interface.
+ */
+public interface ColsOfKindColumnsSelectionDsl {
+
+    /**
+     * ## Cols Of Kind Grammar
+     *
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * [(What is this notation?)][org.jetbrains.kotlinx.dataframe.documentation.DslGrammar]
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  ### Definitions:
+     *  `columnSet: `[`ColumnSet`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]`<*>`
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  `columnGroup: `[`SingleColumn`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]`<`[`DataRow`][org.jetbrains.kotlinx.dataframe.DataRow]`<*>> | `[`String`][String]`  |  `[`KProperty`][kotlin.reflect.KProperty]`<* | `[`DataRow`][org.jetbrains.kotlinx.dataframe.DataRow]`<*>> | `[`ColumnPath`][org.jetbrains.kotlinx.dataframe.columns.ColumnPath]
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  `condition: `[`ColumnFilter`][org.jetbrains.kotlinx.dataframe.ColumnFilter]
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  `kind: `[`ColumnKind`][org.jetbrains.kotlinx.dataframe.columns.ColumnKind]
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  ### What can be called directly in the [Columns Selection DSL][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl]:
+     *
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  [**`colsOfKind`**][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroups]**`(`**[`kind`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ColumnKindDef]**`,`**` ..`**`)`**`  [  `**`{ `**[`condition`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ConditionDef]**` }`**` ]`
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  ### What can be called on a [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]:
+     *
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  [`columnSet`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ColumnSetDef]
+     *
+     *  &nbsp;&nbsp;&nbsp;&nbsp;__`.`__[**`colsOfKind`**][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroups]**`(`**[`kind`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ColumnKindDef]**`,`**` ..`**`)`**`  [  `**`{ `**[`condition`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ConditionDef]**` }`**` ]`
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  ### What can be called on a [Column Group (reference)][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ColumnGroupDef]:
+     *
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  [`columnGroup`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ColumnGroupDef]
+     *
+     *  &nbsp;&nbsp;&nbsp;&nbsp;__`.`__[**`colsOfKind`**][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroups]**`(`**[`kind`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ColumnKindDef]**`,`**` ..`**`)`**`  [  `**`{ `**[`condition`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ConditionDef]**` }`**` ]`
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     */
+    public interface Grammar {
+
+        /** [**`colsOfKind`**][ColumnsSelectionDsl.colGroups] */
+        public interface PlainDslName
+
+        /** __`.`__[**`colsOfKind`**][ColumnsSelectionDsl.colGroups] */
+        public interface ColumnSetName
+
+        /** __`.`__[**`colsOfKind`**][ColumnsSelectionDsl.colGroups] */
+        public interface ColumnGroupName
+    }
+
+    /**
+     * ## Cols Of Kind
+     * Creates a subset of columns from [this] that are of the given kind(s).
+     *
+     * You can optionally use a [filter] to only include certain columns.
+     * [colsOfKind] can be called using any of the supported [APIs][AccessApi] (+ [ColumnPath]).
+     *
+     * This function operates solely on columns at the top-level.
+     *
+     * ### Check out: [Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][DataFrame.select]`  {  `[colsOfKind][ColumnsSelectionDsl.colsOfKind]`(`[Value][ColumnKind.Value]`, `[Frame][ColumnKind.Frame]`) { it.`[name][ColumnReference.name]`.`[startsWith][String.startsWith]`("my") } }`
+     *
+     *  `df.`[select][DataFrame.select]`  {  `[colsOfKind][ColumnsSelectionDsl.colsOfKind]`(`[Group][ColumnKind.Group]`) }`
+     *
+     *  `df.`[select][DataFrame.select]` { "myColGroup".`[colsOfKind][String.colsOfKind]`(`[Frame][ColumnKind.Frame]`) }`
+     *
+     * #### Examples for this overload:
+     *
+     *
+     *
+     * @param [filter] An optional [predicate][ColumnFilter] to filter the columns of given kind(s) by.
+     * @param [kind] The [kind][ColumnKind] of columns to include.
+     * @param [others] Other optional [kinds][ColumnKind] of columns to include.
+     * @return A [ColumnSet] of columns of the given kind(s).
+     * @see [ColumnsSelectionDsl.valueCols]
+     * @see [ColumnsSelectionDsl.frameCols]
+     * @see [ColumnsSelectionDsl.colGroups]
+     * @see [ColumnsSelectionDsl.cols]
+     */
+    private interface CommonColsOfKindDocs {
+
+        /** Example argument */
+        interface ExampleArg
+    }
+
+    /**
+     * ## Cols Of Kind
+     * Creates a subset of columns from [this] that are of the given kind(s).
+     *
+     * You can optionally use a [filter] to only include certain columns.
+     * [colsOfKind][org.jetbrains.kotlinx.dataframe.api.ColsOfKindColumnsSelectionDsl.colsOfKind] can be called using any of the supported [APIs][org.jetbrains.kotlinx.dataframe.documentation.AccessApi] (+ [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath]).
+     *
+     * This function operates solely on columns at the top-level.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColsOfKindColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsOfKind][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOfKind]`(`[Value][org.jetbrains.kotlinx.dataframe.columns.ColumnKind.Value]`, `[Frame][org.jetbrains.kotlinx.dataframe.columns.ColumnKind.Frame]`) { it.`[name][org.jetbrains.kotlinx.dataframe.columns.ColumnReference.name]`.`[startsWith][String.startsWith]`("my") } }`
+     *
+     *  `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsOfKind][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOfKind]`(`[Group][org.jetbrains.kotlinx.dataframe.columns.ColumnKind.Group]`) }`
+     *
+     *  `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "myColGroup".`[colsOfKind][kotlin.String.colsOfKind]`(`[Frame][org.jetbrains.kotlinx.dataframe.columns.ColumnKind.Frame]`) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][DataFrame.select]`  {  `[cols][ColumnsSelectionDsl.cols]` { it.`[name][ColumnReference.name]`.`[startsWith][String.startsWith]`("my") }.`[colsOfKind][ColumnSet.colsOfKind]`(`[Value][ColumnKind.Value]`, `[Frame][ColumnKind.Frame]`) }`
+     *
+     * `// NOTE: This can be shortened to just:`
+     *
+     * `df.`[select][DataFrame.select]`  {  `[colsOfKind][ColumnsSelectionDsl.colsOfKind]`(`[Value][ColumnKind.Value]`, `[Frame][ColumnKind.Frame]`) { it.`[name][ColumnReference.name]`.`[startsWith][String.startsWith]`("my") } }`
+     *
+     * @param [filter] An optional [predicate][org.jetbrains.kotlinx.dataframe.ColumnFilter] to filter the columns of given kind(s) by.
+     * @param [kind] The [kind][org.jetbrains.kotlinx.dataframe.columns.ColumnKind] of columns to include.
+     * @param [others] Other optional [kinds][org.jetbrains.kotlinx.dataframe.columns.ColumnKind] of columns to include.
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] of columns of the given kind(s).
+     * @see [ColumnsSelectionDsl.valueCols]
+     * @see [ColumnsSelectionDsl.frameCols]
+     * @see [ColumnsSelectionDsl.colGroups]
+     * @see [ColumnsSelectionDsl.cols]
+     */
+    public fun ColumnSet<*>.colsOfKind(
+        kind: ColumnKind,
+        vararg others: ColumnKind,
+        filter: ColumnFilter<*> = { true },
+    ): TransformableColumnSet<*> =
+        columnsOfKindInternal(
+            kinds = headPlusArray(kind, others).toSet(),
+            filter = filter,
+        )
+
+    /**
+     * ## Cols Of Kind
+     * Creates a subset of columns from [this] that are of the given kind(s).
+     *
+     * You can optionally use a [filter] to only include certain columns.
+     * [colsOfKind][org.jetbrains.kotlinx.dataframe.api.ColsOfKindColumnsSelectionDsl.colsOfKind] can be called using any of the supported [APIs][org.jetbrains.kotlinx.dataframe.documentation.AccessApi] (+ [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath]).
+     *
+     * This function operates solely on columns at the top-level.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColsOfKindColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsOfKind][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOfKind]`(`[Value][org.jetbrains.kotlinx.dataframe.columns.ColumnKind.Value]`, `[Frame][org.jetbrains.kotlinx.dataframe.columns.ColumnKind.Frame]`) { it.`[name][org.jetbrains.kotlinx.dataframe.columns.ColumnReference.name]`.`[startsWith][String.startsWith]`("my") } }`
+     *
+     *  `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsOfKind][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOfKind]`(`[Group][org.jetbrains.kotlinx.dataframe.columns.ColumnKind.Group]`) }`
+     *
+     *  `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "myColGroup".`[colsOfKind][kotlin.String.colsOfKind]`(`[Frame][org.jetbrains.kotlinx.dataframe.columns.ColumnKind.Frame]`) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][DataFrame.select]`  {  `[colsOfKind][ColumnsSelectionDsl.colsOfKind]`(`[Value][ColumnKind.Value]`, `[Frame][ColumnKind.Frame]`) { it.`[name][ColumnReference.name]`.`[startsWith][String.startsWith]`("my") } }`
+     *
+     * @param [filter] An optional [predicate][org.jetbrains.kotlinx.dataframe.ColumnFilter] to filter the columns of given kind(s) by.
+     * @param [kind] The [kind][org.jetbrains.kotlinx.dataframe.columns.ColumnKind] of columns to include.
+     * @param [others] Other optional [kinds][org.jetbrains.kotlinx.dataframe.columns.ColumnKind] of columns to include.
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] of columns of the given kind(s).
+     * @see [ColumnsSelectionDsl.valueCols]
+     * @see [ColumnsSelectionDsl.frameCols]
+     * @see [ColumnsSelectionDsl.colGroups]
+     * @see [ColumnsSelectionDsl.cols]
+     */
+    public fun ColumnsSelectionDsl<*>.colsOfKind(
+        kind: ColumnKind,
+        vararg others: ColumnKind,
+        filter: ColumnFilter<*> = { true },
+    ): TransformableColumnSet<*> =
+        asSingleColumn().columnsOfKindInternal(
+            kinds = headPlusArray(kind, others).toSet(),
+            filter = filter,
+        )
+
+    /**
+     * ## Cols Of Kind
+     * Creates a subset of columns from [this] that are of the given kind(s).
+     *
+     * You can optionally use a [filter] to only include certain columns.
+     * [colsOfKind][org.jetbrains.kotlinx.dataframe.api.ColsOfKindColumnsSelectionDsl.colsOfKind] can be called using any of the supported [APIs][org.jetbrains.kotlinx.dataframe.documentation.AccessApi] (+ [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath]).
+     *
+     * This function operates solely on columns at the top-level.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColsOfKindColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsOfKind][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOfKind]`(`[Value][org.jetbrains.kotlinx.dataframe.columns.ColumnKind.Value]`, `[Frame][org.jetbrains.kotlinx.dataframe.columns.ColumnKind.Frame]`) { it.`[name][org.jetbrains.kotlinx.dataframe.columns.ColumnReference.name]`.`[startsWith][String.startsWith]`("my") } }`
+     *
+     *  `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsOfKind][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOfKind]`(`[Group][org.jetbrains.kotlinx.dataframe.columns.ColumnKind.Group]`) }`
+     *
+     *  `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "myColGroup".`[colsOfKind][kotlin.String.colsOfKind]`(`[Frame][org.jetbrains.kotlinx.dataframe.columns.ColumnKind.Frame]`) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][DataFrame.select]` { myColumnGroup.`[colsOfKind][SingleColumn.colsOfKind]`(`[Value][ColumnKind.Value]`, `[Frame][ColumnKind.Frame]`) }`
+     *
+     * @param [filter] An optional [predicate][org.jetbrains.kotlinx.dataframe.ColumnFilter] to filter the columns of given kind(s) by.
+     * @param [kind] The [kind][org.jetbrains.kotlinx.dataframe.columns.ColumnKind] of columns to include.
+     * @param [others] Other optional [kinds][org.jetbrains.kotlinx.dataframe.columns.ColumnKind] of columns to include.
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] of columns of the given kind(s).
+     * @see [ColumnsSelectionDsl.valueCols]
+     * @see [ColumnsSelectionDsl.frameCols]
+     * @see [ColumnsSelectionDsl.colGroups]
+     * @see [ColumnsSelectionDsl.cols]
+     */
+    public fun SingleColumn<DataRow<*>>.colsOfKind(
+        kind: ColumnKind,
+        vararg others: ColumnKind,
+        filter: ColumnFilter<*> = { true },
+    ): TransformableColumnSet<*> =
+        this.ensureIsColumnGroup().columnsOfKindInternal(
+            kinds = headPlusArray(kind, others).toSet(),
+            filter = filter,
+        )
+
+    /**
+     * ## Cols Of Kind
+     * Creates a subset of columns from [this] that are of the given kind(s).
+     *
+     * You can optionally use a [filter] to only include certain columns.
+     * [colsOfKind][org.jetbrains.kotlinx.dataframe.api.ColsOfKindColumnsSelectionDsl.colsOfKind] can be called using any of the supported [APIs][org.jetbrains.kotlinx.dataframe.documentation.AccessApi] (+ [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath]).
+     *
+     * This function operates solely on columns at the top-level.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColsOfKindColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsOfKind][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOfKind]`(`[Value][org.jetbrains.kotlinx.dataframe.columns.ColumnKind.Value]`, `[Frame][org.jetbrains.kotlinx.dataframe.columns.ColumnKind.Frame]`) { it.`[name][org.jetbrains.kotlinx.dataframe.columns.ColumnReference.name]`.`[startsWith][String.startsWith]`("my") } }`
+     *
+     *  `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsOfKind][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOfKind]`(`[Group][org.jetbrains.kotlinx.dataframe.columns.ColumnKind.Group]`) }`
+     *
+     *  `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "myColGroup".`[colsOfKind][kotlin.String.colsOfKind]`(`[Frame][org.jetbrains.kotlinx.dataframe.columns.ColumnKind.Frame]`) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][DataFrame.select]` { "myColumnGroup".`[colsOfKind][SingleColumn.colsOfKind]`(`[Value][ColumnKind.Value]`, `[Frame][ColumnKind.Frame]`) }`
+     *
+     * @param [filter] An optional [predicate][org.jetbrains.kotlinx.dataframe.ColumnFilter] to filter the columns of given kind(s) by.
+     * @param [kind] The [kind][org.jetbrains.kotlinx.dataframe.columns.ColumnKind] of columns to include.
+     * @param [others] Other optional [kinds][org.jetbrains.kotlinx.dataframe.columns.ColumnKind] of columns to include.
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] of columns of the given kind(s).
+     * @see [ColumnsSelectionDsl.valueCols]
+     * @see [ColumnsSelectionDsl.frameCols]
+     * @see [ColumnsSelectionDsl.colGroups]
+     * @see [ColumnsSelectionDsl.cols]
+     */
+    public fun String.colsOfKind(
+        kind: ColumnKind,
+        vararg others: ColumnKind,
+        filter: ColumnFilter<*> = { true },
+    ): TransformableColumnSet<*> = columnGroup(this).colsOfKind(kind, *others, filter = filter)
+
+    /**
+     * ## Cols Of Kind
+     * Creates a subset of columns from [this] that are of the given kind(s).
+     *
+     * You can optionally use a [filter] to only include certain columns.
+     * [colsOfKind][org.jetbrains.kotlinx.dataframe.api.ColsOfKindColumnsSelectionDsl.colsOfKind] can be called using any of the supported [APIs][org.jetbrains.kotlinx.dataframe.documentation.AccessApi] (+ [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath]).
+     *
+     * This function operates solely on columns at the top-level.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColsOfKindColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsOfKind][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOfKind]`(`[Value][org.jetbrains.kotlinx.dataframe.columns.ColumnKind.Value]`, `[Frame][org.jetbrains.kotlinx.dataframe.columns.ColumnKind.Frame]`) { it.`[name][org.jetbrains.kotlinx.dataframe.columns.ColumnReference.name]`.`[startsWith][String.startsWith]`("my") } }`
+     *
+     *  `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsOfKind][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOfKind]`(`[Group][org.jetbrains.kotlinx.dataframe.columns.ColumnKind.Group]`) }`
+     *
+     *  `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "myColGroup".`[colsOfKind][kotlin.String.colsOfKind]`(`[Frame][org.jetbrains.kotlinx.dataframe.columns.ColumnKind.Frame]`) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][DataFrame.select]` { Type::myColumnGroup.`[colsOfKind][KProperty.colsOfKind]`(`[Value][ColumnKind.Value]`, `[Frame][ColumnKind.Frame]`) }`
+     *
+     * @param [filter] An optional [predicate][org.jetbrains.kotlinx.dataframe.ColumnFilter] to filter the columns of given kind(s) by.
+     * @param [kind] The [kind][org.jetbrains.kotlinx.dataframe.columns.ColumnKind] of columns to include.
+     * @param [others] Other optional [kinds][org.jetbrains.kotlinx.dataframe.columns.ColumnKind] of columns to include.
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] of columns of the given kind(s).
+     * @see [ColumnsSelectionDsl.valueCols]
+     * @see [ColumnsSelectionDsl.frameCols]
+     * @see [ColumnsSelectionDsl.colGroups]
+     * @see [ColumnsSelectionDsl.cols]
+     */
+    public fun KProperty<*>.colsOfKind(
+        kind: ColumnKind,
+        vararg others: ColumnKind,
+        filter: ColumnFilter<*> = { true },
+    ): TransformableColumnSet<*> = columnGroup(this).colsOfKind(kind, *others, filter = filter)
+
+    /**
+     * ## Cols Of Kind
+     * Creates a subset of columns from [this] that are of the given kind(s).
+     *
+     * You can optionally use a [filter] to only include certain columns.
+     * [colsOfKind][org.jetbrains.kotlinx.dataframe.api.ColsOfKindColumnsSelectionDsl.colsOfKind] can be called using any of the supported [APIs][org.jetbrains.kotlinx.dataframe.documentation.AccessApi] (+ [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath]).
+     *
+     * This function operates solely on columns at the top-level.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColsOfKindColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsOfKind][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOfKind]`(`[Value][org.jetbrains.kotlinx.dataframe.columns.ColumnKind.Value]`, `[Frame][org.jetbrains.kotlinx.dataframe.columns.ColumnKind.Frame]`) { it.`[name][org.jetbrains.kotlinx.dataframe.columns.ColumnReference.name]`.`[startsWith][String.startsWith]`("my") } }`
+     *
+     *  `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsOfKind][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOfKind]`(`[Group][org.jetbrains.kotlinx.dataframe.columns.ColumnKind.Group]`) }`
+     *
+     *  `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "myColGroup".`[colsOfKind][kotlin.String.colsOfKind]`(`[Frame][org.jetbrains.kotlinx.dataframe.columns.ColumnKind.Frame]`) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][DataFrame.select]` { "pathTo"["myColumnGroup"].`[colsOfKind][ColumnPath.colsOfKind]`(`[Value][ColumnKind.Value]`, `[Frame][ColumnKind.Frame]`) }`
+     *
+     * @param [filter] An optional [predicate][org.jetbrains.kotlinx.dataframe.ColumnFilter] to filter the columns of given kind(s) by.
+     * @param [kind] The [kind][org.jetbrains.kotlinx.dataframe.columns.ColumnKind] of columns to include.
+     * @param [others] Other optional [kinds][org.jetbrains.kotlinx.dataframe.columns.ColumnKind] of columns to include.
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] of columns of the given kind(s).
+     * @see [ColumnsSelectionDsl.valueCols]
+     * @see [ColumnsSelectionDsl.frameCols]
+     * @see [ColumnsSelectionDsl.colGroups]
+     * @see [ColumnsSelectionDsl.cols]
+     */
+    public fun ColumnPath.colsOfKind(
+        kind: ColumnKind,
+        vararg others: ColumnKind,
+        filter: ColumnFilter<*> = { true },
+    ): TransformableColumnSet<*> = columnGroup(this).colsOfKind(kind, *others, filter = filter)
+
+    // endregion
+}
+
+/**
+ * Returns a TransformableColumnSet containing the columns of given kind(s) that satisfy the given filter.
+ *
+ * @param filter The filter function to apply on each column. Must accept a ColumnWithPath object and return a Boolean.
+ * @return A [TransformableColumnSet] containing the columns of given kinds that satisfy the filter.
+ */
+internal fun ColumnsResolver<*>.columnsOfKindInternal(
+    kinds: Set<ColumnKind>,
+    filter: ColumnFilter<*>,
+): TransformableColumnSet<*> = colsInternal { it.kind() in kinds && filter(it) }
+
+// endregion
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/columnNameFilters.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/columnNameFilters.kt
new file mode 100644
index 000000000..5c9b0d0ae
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/columnNameFilters.kt
@@ -0,0 +1,1095 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.DataRow
+import org.jetbrains.kotlinx.dataframe.columns.ColumnGroup
+import org.jetbrains.kotlinx.dataframe.columns.ColumnPath
+import org.jetbrains.kotlinx.dataframe.columns.ColumnSet
+import org.jetbrains.kotlinx.dataframe.columns.SingleColumn
+import org.jetbrains.kotlinx.dataframe.impl.columns.TransformableColumnSet
+import kotlin.reflect.KProperty
+
+// region ColumnsSelectionDsl
+
+/**
+ * ## (Cols) Name (Contains / StartsWith / EndsWith) [Columns Selection DSL][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl]
+ *
+ * See [Grammar] for all functions in this interface.
+ */
+public interface ColumnNameFiltersColumnsSelectionDsl {
+
+    /**
+     * ## (Cols) Name (Contains / StartsWith / EndsWith) Grammar
+     *
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * [(What is this notation?)][org.jetbrains.kotlinx.dataframe.documentation.DslGrammar]
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  ### Definitions:
+     *  `columnSet: `[`ColumnSet`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]`<*>`
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  `columnGroup: `[`SingleColumn`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]`<`[`DataRow`][org.jetbrains.kotlinx.dataframe.DataRow]`<*>> | `[`String`][String]`  |  `[`KProperty`][kotlin.reflect.KProperty]`<* | `[`DataRow`][org.jetbrains.kotlinx.dataframe.DataRow]`<*>> | `[`ColumnPath`][org.jetbrains.kotlinx.dataframe.columns.ColumnPath]
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  `text: `[`String`][String]
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  `ignoreCase: `[`Boolean`][Boolean]
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  `regex: `[`Regex`][Regex]
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  ### What can be called directly in the [Columns Selection DSL][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl]:
+     *
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  [**`nameContains`**][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.nameContains]**`(`**[`text`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.TextDef]`[`**`, `**[`ignoreCase`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.IgnoreCaseDef]`] | `[`regex`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.RegexDef]**`)`**
+     *
+     *  `| `__`name`__`(`[**`Starts`**][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.nameStartsWith]`|`[**`Ends`**][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.nameEndsWith]`)`**`With`**__`(`__[`text`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.TextDef]`[`**`, `**[`ignoreCase`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.IgnoreCaseDef]`]`**`)`**
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  ### What can be called on a [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]:
+     *
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  [`columnSet`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ColumnSetDef]
+     *
+     *  &nbsp;&nbsp;&nbsp;&nbsp;__`.`__[**`nameContains`**][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.nameContains]**`(`**[`text`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.TextDef]`[`**`, `**[`ignoreCase`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.IgnoreCaseDef]`] | `[`regex`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.RegexDef]**`)`**
+     *
+     *  &nbsp;&nbsp;&nbsp;&nbsp;`| `__`.name`__`(`[**`Starts`**][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.nameStartsWith]`|`[**`Ends`**][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.nameEndsWith]`)`**`With`**__`(`__[`text`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.TextDef]`[`**`, `**[`ignoreCase`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.IgnoreCaseDef]`]`**`)`**
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  ### What can be called on a [Column Group (reference)][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ColumnGroupDef]:
+     *
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  [`columnGroup`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ColumnGroupDef]
+     *
+     *  &nbsp;&nbsp;&nbsp;&nbsp;__`.`__[**`colsNameContains`**][org.jetbrains.kotlinx.dataframe.api.ColumnNameFiltersColumnsSelectionDsl.colsNameContains]**`(`**[`text`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.TextDef]`[`**`, `**[`ignoreCase`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.IgnoreCaseDef]`] | `[`regex`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.RegexDef]**`)`**
+     *
+     *  &nbsp;&nbsp;&nbsp;&nbsp;`| `__`.colsName`__`(`[**`Starts`**][org.jetbrains.kotlinx.dataframe.api.ColumnNameFiltersColumnsSelectionDsl.colsNameStartsWith]`|`[**`Ends`**][org.jetbrains.kotlinx.dataframe.api.ColumnNameFiltersColumnsSelectionDsl.colsNameEndsWith]`)`**`With`**__`(`__[`text`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.TextDef]`[`**`, `**[`ignoreCase`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.IgnoreCaseDef]`]`**`)`**
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     */
+    public interface Grammar {
+
+        /** [**`nameContains`**][ColumnsSelectionDsl.nameContains] */
+        public interface PlainDslNameContains
+
+        /** __`name`__`(`[**`Starts`**][ColumnsSelectionDsl.nameStartsWith]`|`[**`Ends`**][ColumnsSelectionDsl.nameEndsWith]`)`**`With`** */
+        public interface PlainDslNameStartsEndsWith
+
+        /** __`.`__[**`nameContains`**][ColumnsSelectionDsl.nameContains] */
+        public interface ColumnSetNameContains
+
+        /** __`.name`__`(`[**`Starts`**][ColumnsSelectionDsl.nameStartsWith]`|`[**`Ends`**][ColumnsSelectionDsl.nameEndsWith]`)`**`With`** */
+        public interface ColumnSetNameStartsEndsWith
+
+        /**__`.`__[**`colsNameContains`**][ColumnsSelectionDsl.colsNameContains] */
+        public interface ColumnGroupNameContains
+
+        /** __`.colsName`__`(`[**`Starts`**][ColumnsSelectionDsl.colsNameStartsWith]`|`[**`Ends`**][ColumnsSelectionDsl.colsNameEndsWith]`)`**`With`** */
+        public interface ColumnGroupNameStartsWith
+    }
+
+    // region nameContains
+
+    /**
+     * ## (Cols) Name Contains
+     * Returns a [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns from [this] having
+     * [text] in their name.
+     *
+     * This function operates solely on columns at the top-level.
+     *
+     * NOTE: For [column groups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup], `nameContains` is named `colsNameContains` to avoid confusion.
+     *
+     * This function is a shorthand for [cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`  {  `[text][text]` `[in][String.contains]` it.`[name][org.jetbrains.kotlinx.dataframe.DataColumn.name]` }`.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColumnNameFiltersColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[nameContains][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.colsNameContains]`("my") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "someGroupCol".`[nameContains][kotlin.String.colsNameContains]`(`[Regex][Regex]`("my[a-zA-Z][a-zA-Z0-9]*")) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { Type::someGroupCol.`[nameContains][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.colsNameContains]`("my", ignoreCase = true) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][DataFrame.select]`  {  `[cols][ColumnsSelectionDsl.cols]` { .. }.`[nameContains][ColumnSet.nameContains]`("my") }`
+     *
+     * `df.`[select][DataFrame.select]`  {  `[colsOf][SingleColumn.colsOf]`<`[Int][Int]`>().`[nameContains][ColumnSet.nameContains]`("my", ignoreCase = true) }`
+     *
+     * @param [text] what the column name should contain to be included in the result.
+     * @param [ignoreCase] `true` to ignore character case when comparing strings. By default `false`.
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing
+     *   all columns containing [text] in their name.
+     * @see [nameEndsWith]
+     * @see [nameStartsWith]
+     *
+     */
+    @Suppress("UNCHECKED_CAST")
+    public fun <C> ColumnSet<C>.nameContains(
+        text: CharSequence,
+        ignoreCase: Boolean = false,
+    ): TransformableColumnSet<C> = colsInternal { it.name.contains(text, ignoreCase) } as TransformableColumnSet<C>
+
+    /**
+     * ## (Cols) Name Contains
+     * Returns a [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns from [this] having
+     * [text] in their name.
+     *
+     * This function operates solely on columns at the top-level.
+     *
+     * NOTE: For [column groups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup], `nameContains` is named `colsNameContains` to avoid confusion.
+     *
+     * This function is a shorthand for [cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`  {  `[text][text]` `[in][String.contains]` it.`[name][org.jetbrains.kotlinx.dataframe.DataColumn.name]` }`.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColumnNameFiltersColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[nameContains][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.colsNameContains]`("my") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "someGroupCol".`[nameContains][kotlin.String.colsNameContains]`(`[Regex][Regex]`("my[a-zA-Z][a-zA-Z0-9]*")) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { Type::someGroupCol.`[nameContains][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.colsNameContains]`("my", ignoreCase = true) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][DataFrame.select]`  {  `[nameContains][ColumnsSelectionDsl.colsNameContains]`("my") }`
+     *
+     * @param [text] what the column name should contain to be included in the result.
+     * @param [ignoreCase] `true` to ignore character case when comparing strings. By default `false`.
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing
+     *   all columns containing [text] in their name.
+     * @see [nameEndsWith]
+     * @see [nameStartsWith]
+     *
+     */
+    public fun ColumnsSelectionDsl<*>.nameContains(
+        text: CharSequence,
+        ignoreCase: Boolean = false,
+    ): TransformableColumnSet<*> = asSingleColumn().colsNameContains(text, ignoreCase)
+
+    /**
+     * ## (Cols) Name Contains
+     * Returns a [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns from [this] having
+     * [text] in their name.
+     *
+     * This function operates solely on columns at the top-level.
+     *
+     * NOTE: For [column groups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup], `nameContains` is named `colsNameContains` to avoid confusion.
+     *
+     * This function is a shorthand for [cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`  {  `[text][text]` `[in][String.contains]` it.`[name][org.jetbrains.kotlinx.dataframe.DataColumn.name]` }`.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColumnNameFiltersColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[nameContains][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.colsNameContains]`("my") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "someGroupCol".`[nameContains][kotlin.String.colsNameContains]`(`[Regex][Regex]`("my[a-zA-Z][a-zA-Z0-9]*")) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { Type::someGroupCol.`[nameContains][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.colsNameContains]`("my", ignoreCase = true) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][DataFrame.select]` { someGroupCol.`[colsNameContains][SingleColumn.colsNameContains]`("my") }`
+     *
+     * @param [text] what the column name should contain to be included in the result.
+     * @param [ignoreCase] `true` to ignore character case when comparing strings. By default `false`.
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing
+     *   all columns containing [text] in their name.
+     * @see [nameEndsWith]
+     * @see [nameStartsWith]
+     *
+     */
+    public fun SingleColumn<DataRow<*>>.colsNameContains(
+        text: CharSequence,
+        ignoreCase: Boolean = false,
+    ): TransformableColumnSet<*> = this.ensureIsColumnGroup().colsInternal { it.name.contains(text, ignoreCase) }
+
+    /**
+     * ## (Cols) Name Contains
+     * Returns a [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns from [this] having
+     * [text] in their name.
+     *
+     * This function operates solely on columns at the top-level.
+     *
+     * NOTE: For [column groups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup], `nameContains` is named `colsNameContains` to avoid confusion.
+     *
+     * This function is a shorthand for [cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`  {  `[text][text]` `[in][String.contains]` it.`[name][org.jetbrains.kotlinx.dataframe.DataColumn.name]` }`.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColumnNameFiltersColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[nameContains][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.colsNameContains]`("my") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "someGroupCol".`[nameContains][kotlin.String.colsNameContains]`(`[Regex][Regex]`("my[a-zA-Z][a-zA-Z0-9]*")) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { Type::someGroupCol.`[nameContains][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.colsNameContains]`("my", ignoreCase = true) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][DataFrame.select]` { "someGroupCol".`[colsNameContains][String.colsNameContains]`("my") }`
+     *
+     * @param [text] what the column name should contain to be included in the result.
+     * @param [ignoreCase] `true` to ignore character case when comparing strings. By default `false`.
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing
+     *   all columns containing [text] in their name.
+     * @see [nameEndsWith]
+     * @see [nameStartsWith]
+     *
+     */
+    public fun String.colsNameContains(text: CharSequence, ignoreCase: Boolean = false): TransformableColumnSet<*> =
+        columnGroup(this).colsNameContains(text, ignoreCase)
+
+    /**
+     * ## (Cols) Name Contains
+     * Returns a [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns from [this] having
+     * [text] in their name.
+     *
+     * This function operates solely on columns at the top-level.
+     *
+     * NOTE: For [column groups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup], `nameContains` is named `colsNameContains` to avoid confusion.
+     *
+     * This function is a shorthand for [cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`  {  `[text][text]` `[in][String.contains]` it.`[name][org.jetbrains.kotlinx.dataframe.DataColumn.name]` }`.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColumnNameFiltersColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[nameContains][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.colsNameContains]`("my") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "someGroupCol".`[nameContains][kotlin.String.colsNameContains]`(`[Regex][Regex]`("my[a-zA-Z][a-zA-Z0-9]*")) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { Type::someGroupCol.`[nameContains][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.colsNameContains]`("my", ignoreCase = true) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][DataFrame.select]` { DataSchemaType::someGroupCol.`[colsNameContains][KProperty.colsNameContains]`("my") }`
+     *
+     * @param [text] what the column name should contain to be included in the result.
+     * @param [ignoreCase] `true` to ignore character case when comparing strings. By default `false`.
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing
+     *   all columns containing [text] in their name.
+     * @see [nameEndsWith]
+     * @see [nameStartsWith]
+     *
+     */
+    public fun KProperty<*>.colsNameContains(
+        text: CharSequence,
+        ignoreCase: Boolean = false,
+    ): TransformableColumnSet<*> = columnGroup(this).colsNameContains(text, ignoreCase)
+
+    /**
+     * ## (Cols) Name Contains
+     * Returns a [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns from [this] having
+     * [text] in their name.
+     *
+     * This function operates solely on columns at the top-level.
+     *
+     * NOTE: For [column groups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup], `nameContains` is named `colsNameContains` to avoid confusion.
+     *
+     * This function is a shorthand for [cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`  {  `[text][text]` `[in][String.contains]` it.`[name][org.jetbrains.kotlinx.dataframe.DataColumn.name]` }`.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColumnNameFiltersColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[nameContains][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.colsNameContains]`("my") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "someGroupCol".`[nameContains][kotlin.String.colsNameContains]`(`[Regex][Regex]`("my[a-zA-Z][a-zA-Z0-9]*")) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { Type::someGroupCol.`[nameContains][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.colsNameContains]`("my", ignoreCase = true) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][DataFrame.select]` { "pathTo"["someGroupCol"].`[colsNameContains][ColumnPath.colsNameContains]`("my") }`
+     *
+     * @param [text] what the column name should contain to be included in the result.
+     * @param [ignoreCase] `true` to ignore character case when comparing strings. By default `false`.
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing
+     *   all columns containing [text] in their name.
+     * @see [nameEndsWith]
+     * @see [nameStartsWith]
+     *
+     */
+    public fun ColumnPath.colsNameContains(
+        text: CharSequence,
+        ignoreCase: Boolean = false,
+    ): TransformableColumnSet<*> = columnGroup(this).colsNameContains(text, ignoreCase)
+
+    /**
+     * ## (Cols) Name Contains
+     * Returns a [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns from [this] having
+     * [regex] in their name.
+     *
+     * This function operates solely on columns at the top-level.
+     *
+     * NOTE: For [column groups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup], `nameContains` is named `colsNameContains` to avoid confusion.
+     *
+     * This function is a shorthand for [cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`  {  `[regex][regex]` `[in][String.contains]` it.`[name][org.jetbrains.kotlinx.dataframe.DataColumn.name]` }`.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColumnNameFiltersColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[nameContains][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.colsNameContains]`("my") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "someGroupCol".`[nameContains][kotlin.String.colsNameContains]`(`[Regex][Regex]`("my[a-zA-Z][a-zA-Z0-9]*")) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { Type::someGroupCol.`[nameContains][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.colsNameContains]`("my", ignoreCase = true) }`
+     *
+     * #### Examples for this overload:
+     *
+     *
+     *
+     * @param [regex] what the column name should contain to be included in the result.
+     *
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing
+     *   all columns containing [regex] in their name.
+     * @see [nameEndsWith]
+     * @see [nameStartsWith]
+     *
+     */
+    private interface NameContainsRegexDocs
+
+    /**
+     * ## (Cols) Name Contains
+     * Returns a [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns from [this] having
+     * [regex] in their name.
+     *
+     * This function operates solely on columns at the top-level.
+     *
+     * NOTE: For [column groups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup], `nameContains` is named `colsNameContains` to avoid confusion.
+     *
+     * This function is a shorthand for [cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`  {  `[regex][regex]` `[in][String.contains]` it.`[name][org.jetbrains.kotlinx.dataframe.DataColumn.name]` }`.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColumnNameFiltersColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[nameContains][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.colsNameContains]`("my") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "someGroupCol".`[nameContains][kotlin.String.colsNameContains]`(`[Regex][Regex]`("my[a-zA-Z][a-zA-Z0-9]*")) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { Type::someGroupCol.`[nameContains][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.colsNameContains]`("my", ignoreCase = true) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][DataFrame.select]`  {  `[cols][ColumnsSelectionDsl.cols]` { .. }.`[nameContains][ColumnSet.nameContains]`(`[Regex][Regex]`("order-[0-9]+")) }`
+     *
+     * `df.`[select][DataFrame.select]`  {  `[colsOf][SingleColumn.colsOf]`<`[Int][Int]`>().`[nameContains][ColumnSet.nameContains]`(`[Regex][Regex]`("order-[0-9]+")) }`
+     *
+     * @param [regex] what the column name should contain to be included in the result.
+     *
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing
+     *   all columns containing [regex] in their name.
+     * @see [nameEndsWith]
+     * @see [nameStartsWith]
+     *
+     */
+    @Suppress("UNCHECKED_CAST")
+    public fun <C> ColumnSet<C>.nameContains(regex: Regex): TransformableColumnSet<C> =
+        colsInternal { it.name.contains(regex) } as TransformableColumnSet<C>
+
+    /**
+     * ## (Cols) Name Contains
+     * Returns a [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns from [this] having
+     * [regex] in their name.
+     *
+     * This function operates solely on columns at the top-level.
+     *
+     * NOTE: For [column groups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup], `nameContains` is named `colsNameContains` to avoid confusion.
+     *
+     * This function is a shorthand for [cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`  {  `[regex][regex]` `[in][String.contains]` it.`[name][org.jetbrains.kotlinx.dataframe.DataColumn.name]` }`.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColumnNameFiltersColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[nameContains][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.colsNameContains]`("my") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "someGroupCol".`[nameContains][kotlin.String.colsNameContains]`(`[Regex][Regex]`("my[a-zA-Z][a-zA-Z0-9]*")) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { Type::someGroupCol.`[nameContains][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.colsNameContains]`("my", ignoreCase = true) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][DataFrame.select]`  {  `[nameContains][ColumnsSelectionDsl.nameContains]`(`[Regex][Regex]`("order-[0-9]+")) }`
+     *
+     * @param [regex] what the column name should contain to be included in the result.
+     *
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing
+     *   all columns containing [regex] in their name.
+     * @see [nameEndsWith]
+     * @see [nameStartsWith]
+     *
+     */
+    public fun ColumnsSelectionDsl<*>.nameContains(regex: Regex): TransformableColumnSet<*> =
+        asSingleColumn().colsNameContains(regex)
+
+    /**
+     * ## (Cols) Name Contains
+     * Returns a [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns from [this] having
+     * [regex] in their name.
+     *
+     * This function operates solely on columns at the top-level.
+     *
+     * NOTE: For [column groups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup], `nameContains` is named `colsNameContains` to avoid confusion.
+     *
+     * This function is a shorthand for [cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`  {  `[regex][regex]` `[in][String.contains]` it.`[name][org.jetbrains.kotlinx.dataframe.DataColumn.name]` }`.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColumnNameFiltersColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[nameContains][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.colsNameContains]`("my") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "someGroupCol".`[nameContains][kotlin.String.colsNameContains]`(`[Regex][Regex]`("my[a-zA-Z][a-zA-Z0-9]*")) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { Type::someGroupCol.`[nameContains][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.colsNameContains]`("my", ignoreCase = true) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][DataFrame.select]` { someGroupCol.`[colsNameContains][SingleColumn.colsNameContains]`(`[Regex][Regex]`("order-[0-9]+")) }`
+     *
+     * @param [regex] what the column name should contain to be included in the result.
+     *
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing
+     *   all columns containing [regex] in their name.
+     * @see [nameEndsWith]
+     * @see [nameStartsWith]
+     *
+     */
+    public fun SingleColumn<DataRow<*>>.colsNameContains(regex: Regex): TransformableColumnSet<*> =
+        this.ensureIsColumnGroup().colsInternal { it.name.contains(regex) }
+
+    /**
+     * ## (Cols) Name Contains
+     * Returns a [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns from [this] having
+     * [regex] in their name.
+     *
+     * This function operates solely on columns at the top-level.
+     *
+     * NOTE: For [column groups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup], `nameContains` is named `colsNameContains` to avoid confusion.
+     *
+     * This function is a shorthand for [cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`  {  `[regex][regex]` `[in][String.contains]` it.`[name][org.jetbrains.kotlinx.dataframe.DataColumn.name]` }`.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColumnNameFiltersColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[nameContains][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.colsNameContains]`("my") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "someGroupCol".`[nameContains][kotlin.String.colsNameContains]`(`[Regex][Regex]`("my[a-zA-Z][a-zA-Z0-9]*")) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { Type::someGroupCol.`[nameContains][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.colsNameContains]`("my", ignoreCase = true) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][DataFrame.select]` { "someGroupCol".`[colsNameContains][String.colsNameContains]`(`[Regex][Regex]`("order-[0-9]+")) }`
+     *
+     * @param [regex] what the column name should contain to be included in the result.
+     *
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing
+     *   all columns containing [regex] in their name.
+     * @see [nameEndsWith]
+     * @see [nameStartsWith]
+     *
+     */
+    public fun String.colsNameContains(regex: Regex): TransformableColumnSet<*> =
+        columnGroup(this).colsNameContains(regex)
+
+    /**
+     * ## (Cols) Name Contains
+     * Returns a [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns from [this] having
+     * [regex] in their name.
+     *
+     * This function operates solely on columns at the top-level.
+     *
+     * NOTE: For [column groups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup], `nameContains` is named `colsNameContains` to avoid confusion.
+     *
+     * This function is a shorthand for [cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`  {  `[regex][regex]` `[in][String.contains]` it.`[name][org.jetbrains.kotlinx.dataframe.DataColumn.name]` }`.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColumnNameFiltersColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[nameContains][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.colsNameContains]`("my") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "someGroupCol".`[nameContains][kotlin.String.colsNameContains]`(`[Regex][Regex]`("my[a-zA-Z][a-zA-Z0-9]*")) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { Type::someGroupCol.`[nameContains][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.colsNameContains]`("my", ignoreCase = true) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][DataFrame.select]` { DataSchemaType::someGroupCol.`[colsNameContains][KProperty.colsNameContains]`(`[Regex][Regex]`("order-[0-9]+")) }`
+     *
+     * @param [regex] what the column name should contain to be included in the result.
+     *
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing
+     *   all columns containing [regex] in their name.
+     * @see [nameEndsWith]
+     * @see [nameStartsWith]
+     *
+     */
+    public fun KProperty<*>.colsNameContains(regex: Regex): TransformableColumnSet<*> =
+        columnGroup(this).colsNameContains(regex)
+
+    /**
+     * ## (Cols) Name Contains
+     * Returns a [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns from [this] having
+     * [regex] in their name.
+     *
+     * This function operates solely on columns at the top-level.
+     *
+     * NOTE: For [column groups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup], `nameContains` is named `colsNameContains` to avoid confusion.
+     *
+     * This function is a shorthand for [cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`  {  `[regex][regex]` `[in][String.contains]` it.`[name][org.jetbrains.kotlinx.dataframe.DataColumn.name]` }`.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColumnNameFiltersColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[nameContains][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.colsNameContains]`("my") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "someGroupCol".`[nameContains][kotlin.String.colsNameContains]`(`[Regex][Regex]`("my[a-zA-Z][a-zA-Z0-9]*")) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { Type::someGroupCol.`[nameContains][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.colsNameContains]`("my", ignoreCase = true) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][DataFrame.select]` { "pathTo"["someGroupCol"].`[colsNameContains][ColumnPath.colsNameContains]`(`[Regex][Regex]`("order-[0-9]+")) }`
+     *
+     * @param [regex] what the column name should contain to be included in the result.
+     *
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing
+     *   all columns containing [regex] in their name.
+     * @see [nameEndsWith]
+     * @see [nameStartsWith]
+     *
+     */
+    public fun ColumnPath.colsNameContains(regex: Regex): TransformableColumnSet<*> =
+        columnGroup(this).colsNameContains(regex)
+
+    // endregion
+
+    // region nameStartsWith
+
+    @Deprecated("Use nameStartsWith instead", ReplaceWith("this.nameStartsWith(prefix)"))
+    public fun <C> ColumnSet<C>.startsWith(prefix: CharSequence): TransformableColumnSet<C> = nameStartsWith(prefix)
+
+    @Deprecated("Use nameStartsWith instead", ReplaceWith("this.nameStartsWith(prefix)"))
+    public fun ColumnsSelectionDsl<*>.startsWith(prefix: CharSequence): TransformableColumnSet<*> =
+        nameStartsWith(prefix)
+
+    @Deprecated("Use colsNameStartsWith instead", ReplaceWith("this.colsNameStartsWith(prefix)"))
+    public fun SingleColumn<DataRow<*>>.startsWith(prefix: CharSequence): TransformableColumnSet<*> =
+        colsNameStartsWith(prefix)
+
+    /**
+     * ## (Cols) Name Starts With
+     * Returns a [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns from [this]
+     * starting with [prefix] in their name.
+     *
+     * This function operates solely on columns at the top-level.
+     *
+     * NOTE: For [column groups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup], the function is named `colsNameStartsWith` to avoid confusion.
+     *
+     * This function is a shorthand for [cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]` { it.`[name][org.jetbrains.kotlinx.dataframe.DataColumn.name]`.`[startsWith][String.startsWith]`(`[prefix][prefix]`) }`.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColumnNameFiltersColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[nameStartsWith][ColumnsSelectionDsl.nameStartsWith]`("order") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "someGroupCol".`[colsNameStartsWith][String.colsNameStartsWith]`("b") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { Type::someGroupCol.`[colsNameStartsWith][SingleColumn.colsNameStartsWith]`("a", ignoreCase = true) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][DataFrame.select]`  {  `[colsOf][SingleColumn.colsOf]`<`[Int][Int]`>().`[nameStartsWith][ColumnSet.nameStartsWith]`("order-") }`
+     *
+     * @param [prefix] Columns starting with this [prefix] in their name will be returned.
+     * @param [ignoreCase] `true` to ignore character case when comparing strings. By default `false`.
+     *
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing
+     *   all columns starting with [prefix] in their name.
+     * @see [nameEndsWith]
+     * @see [nameContains]
+     */
+    @Suppress("UNCHECKED_CAST")
+    public fun <C> ColumnSet<C>.nameStartsWith(
+        prefix: CharSequence,
+        ignoreCase: Boolean = false,
+    ): TransformableColumnSet<C> = colsInternal { it.name.startsWith(prefix, ignoreCase) } as TransformableColumnSet<C>
+
+    /**
+     * ## (Cols) Name Starts With
+     * Returns a [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns from [this]
+     * starting with [prefix] in their name.
+     *
+     * This function operates solely on columns at the top-level.
+     *
+     * NOTE: For [column groups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup], the function is named `colsNameStartsWith` to avoid confusion.
+     *
+     * This function is a shorthand for [cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]` { it.`[name][org.jetbrains.kotlinx.dataframe.DataColumn.name]`.`[startsWith][String.startsWith]`(`[prefix][prefix]`) }`.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColumnNameFiltersColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[nameStartsWith][ColumnsSelectionDsl.nameStartsWith]`("order") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "someGroupCol".`[colsNameStartsWith][String.colsNameStartsWith]`("b") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { Type::someGroupCol.`[colsNameStartsWith][SingleColumn.colsNameStartsWith]`("a", ignoreCase = true) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][DataFrame.select]`  {  `[nameStartsWith][ColumnsSelectionDsl.nameStartsWith]`("order-") }`
+     *
+     * @param [prefix] Columns starting with this [prefix] in their name will be returned.
+     * @param [ignoreCase] `true` to ignore character case when comparing strings. By default `false`.
+     *
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing
+     *   all columns starting with [prefix] in their name.
+     * @see [nameEndsWith]
+     * @see [nameContains]
+     */
+    public fun ColumnsSelectionDsl<*>.nameStartsWith(
+        prefix: CharSequence,
+        ignoreCase: Boolean = false,
+    ): TransformableColumnSet<*> = asSingleColumn().colsNameStartsWith(prefix, ignoreCase)
+
+    /**
+     * ## (Cols) Name Starts With
+     * Returns a [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns from [this]
+     * starting with [prefix] in their name.
+     *
+     * This function operates solely on columns at the top-level.
+     *
+     * NOTE: For [column groups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup], the function is named `colsNameStartsWith` to avoid confusion.
+     *
+     * This function is a shorthand for [cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]` { it.`[name][org.jetbrains.kotlinx.dataframe.DataColumn.name]`.`[startsWith][String.startsWith]`(`[prefix][prefix]`) }`.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColumnNameFiltersColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[nameStartsWith][ColumnsSelectionDsl.nameStartsWith]`("order") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "someGroupCol".`[colsNameStartsWith][String.colsNameStartsWith]`("b") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { Type::someGroupCol.`[colsNameStartsWith][SingleColumn.colsNameStartsWith]`("a", ignoreCase = true) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][DataFrame.select]` { someGroupCol.`[colsNameStartsWith][SingleColumn.colsNameStartsWith]`("order-") }`
+     *
+     * @param [prefix] Columns starting with this [prefix] in their name will be returned.
+     * @param [ignoreCase] `true` to ignore character case when comparing strings. By default `false`.
+     *
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing
+     *   all columns starting with [prefix] in their name.
+     * @see [nameEndsWith]
+     * @see [nameContains]
+     */
+    public fun SingleColumn<DataRow<*>>.colsNameStartsWith(
+        prefix: CharSequence,
+        ignoreCase: Boolean = false,
+    ): TransformableColumnSet<*> = this.ensureIsColumnGroup().colsInternal { it.name.startsWith(prefix, ignoreCase) }
+
+    /**
+     * ## (Cols) Name Starts With
+     * Returns a [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns from [this]
+     * starting with [prefix] in their name.
+     *
+     * This function operates solely on columns at the top-level.
+     *
+     * NOTE: For [column groups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup], the function is named `colsNameStartsWith` to avoid confusion.
+     *
+     * This function is a shorthand for [cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]` { it.`[name][org.jetbrains.kotlinx.dataframe.DataColumn.name]`.`[startsWith][String.startsWith]`(`[prefix][prefix]`) }`.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColumnNameFiltersColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[nameStartsWith][ColumnsSelectionDsl.nameStartsWith]`("order") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "someGroupCol".`[colsNameStartsWith][String.colsNameStartsWith]`("b") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { Type::someGroupCol.`[colsNameStartsWith][SingleColumn.colsNameStartsWith]`("a", ignoreCase = true) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][DataFrame.select]` { "someGroupCol".`[colsNameStartsWith][String.colsNameStartsWith]`("order-") }`
+     *
+     * @param [prefix] Columns starting with this [prefix] in their name will be returned.
+     * @param [ignoreCase] `true` to ignore character case when comparing strings. By default `false`.
+     *
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing
+     *   all columns starting with [prefix] in their name.
+     * @see [nameEndsWith]
+     * @see [nameContains]
+     */
+    public fun String.colsNameStartsWith(
+        prefix: CharSequence,
+        ignoreCase: Boolean = false,
+    ): TransformableColumnSet<*> = columnGroup(this).colsNameStartsWith(prefix, ignoreCase)
+
+    /**
+     * ## (Cols) Name Starts With
+     * Returns a [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns from [this]
+     * starting with [prefix] in their name.
+     *
+     * This function operates solely on columns at the top-level.
+     *
+     * NOTE: For [column groups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup], the function is named `colsNameStartsWith` to avoid confusion.
+     *
+     * This function is a shorthand for [cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]` { it.`[name][org.jetbrains.kotlinx.dataframe.DataColumn.name]`.`[startsWith][String.startsWith]`(`[prefix][prefix]`) }`.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColumnNameFiltersColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[nameStartsWith][ColumnsSelectionDsl.nameStartsWith]`("order") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "someGroupCol".`[colsNameStartsWith][String.colsNameStartsWith]`("b") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { Type::someGroupCol.`[colsNameStartsWith][SingleColumn.colsNameStartsWith]`("a", ignoreCase = true) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][DataFrame.select]` { DataSchemaType::someGroupCol.`[colsNameStartsWith][KProperty.colsNameStartsWith]`("order-") }`
+     *
+     * @param [prefix] Columns starting with this [prefix] in their name will be returned.
+     * @param [ignoreCase] `true` to ignore character case when comparing strings. By default `false`.
+     *
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing
+     *   all columns starting with [prefix] in their name.
+     * @see [nameEndsWith]
+     * @see [nameContains]
+     */
+    public fun KProperty<*>.colsNameStartsWith(
+        prefix: CharSequence,
+        ignoreCase: Boolean = false,
+    ): TransformableColumnSet<*> = columnGroup(this).colsNameStartsWith(prefix, ignoreCase)
+
+    /**
+     * ## (Cols) Name Starts With
+     * Returns a [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns from [this]
+     * starting with [prefix] in their name.
+     *
+     * This function operates solely on columns at the top-level.
+     *
+     * NOTE: For [column groups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup], the function is named `colsNameStartsWith` to avoid confusion.
+     *
+     * This function is a shorthand for [cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]` { it.`[name][org.jetbrains.kotlinx.dataframe.DataColumn.name]`.`[startsWith][String.startsWith]`(`[prefix][prefix]`) }`.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColumnNameFiltersColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[nameStartsWith][ColumnsSelectionDsl.nameStartsWith]`("order") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "someGroupCol".`[colsNameStartsWith][String.colsNameStartsWith]`("b") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { Type::someGroupCol.`[colsNameStartsWith][SingleColumn.colsNameStartsWith]`("a", ignoreCase = true) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][DataFrame.select]` { "pathTo"["someGroupCol"].`[colsNameStartsWith][ColumnPath.colsNameStartsWith]`("order-") }`
+     *
+     * @param [prefix] Columns starting with this [prefix] in their name will be returned.
+     * @param [ignoreCase] `true` to ignore character case when comparing strings. By default `false`.
+     *
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing
+     *   all columns starting with [prefix] in their name.
+     * @see [nameEndsWith]
+     * @see [nameContains]
+     */
+    public fun ColumnPath.colsNameStartsWith(
+        prefix: CharSequence,
+        ignoreCase: Boolean = false,
+    ): TransformableColumnSet<*> = columnGroup(this).colsNameStartsWith(prefix, ignoreCase)
+
+    // endregion
+
+    // region nameEndsWith
+
+    @Deprecated("Use nameEndsWith instead", ReplaceWith("this.nameEndsWith(suffix)"))
+    @Suppress("UNCHECKED_CAST")
+    public fun <C> ColumnSet<C>.endsWith(suffix: CharSequence): TransformableColumnSet<C> =
+        colsInternal { it.name.endsWith(suffix) } as TransformableColumnSet<C>
+
+    @Deprecated("Use nameEndsWith instead", ReplaceWith("this.nameEndsWith(suffix)"))
+    public fun ColumnsSelectionDsl<*>.endsWith(suffix: CharSequence): TransformableColumnSet<*> = nameEndsWith(suffix)
+
+    @Deprecated("Use colsNameEndsWith instead", ReplaceWith("this.colsNameEndsWith(suffix)"))
+    public fun SingleColumn<DataRow<*>>.endsWith(suffix: CharSequence): TransformableColumnSet<*> =
+        this.ensureIsColumnGroup().colsInternal { it.name.endsWith(suffix) }
+
+    /**
+     * ## (Cols) Name Ends With
+     * Returns a [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns from [this]
+     * ending with [suffix] in their name.
+     *
+     * This function operates solely on columns at the top-level.
+     *
+     * NOTE: For [column groups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup], the function is named `colsNameEndsWith` to avoid confusion.
+     *
+     * This function is a shorthand for [cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]` { it.`[name][org.jetbrains.kotlinx.dataframe.DataColumn.name]`.`[endsWith][String.endsWith]`(`[suffix][suffix]`) }`.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColumnNameFiltersColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[nameEndsWith][ColumnsSelectionDsl.nameEndsWith]`("order") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "someGroupCol".`[colsNameEndsWith][String.colsNameEndsWith]`("b") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { Type::someGroupCol.`[colsNameEndsWith][SingleColumn.colsNameEndsWith]`("a", ignoreCase = true) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][DataFrame.select]`  {  `[colsOf][SingleColumn.colsOf]`<`[Int][Int]`>().`[nameEndsWith][ColumnSet.nameEndsWith]`("-order") }`
+     *
+     * @param [suffix] Columns ending with this [suffix] in their name will be returned.
+     * @param [ignoreCase] `true` to ignore character case when comparing strings. By default `false`.
+     *
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing
+     *   all columns ending with [suffix] in their name.
+     * @see [nameStartsWith]
+     * @see [nameContains]
+     */
+    @Suppress("UNCHECKED_CAST")
+    public fun <C> ColumnSet<C>.nameEndsWith(
+        suffix: CharSequence,
+        ignoreCase: Boolean = false,
+    ): TransformableColumnSet<C> = colsInternal { it.name.endsWith(suffix, ignoreCase) } as TransformableColumnSet<C>
+
+    /**
+     * ## (Cols) Name Ends With
+     * Returns a [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns from [this]
+     * ending with [suffix] in their name.
+     *
+     * This function operates solely on columns at the top-level.
+     *
+     * NOTE: For [column groups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup], the function is named `colsNameEndsWith` to avoid confusion.
+     *
+     * This function is a shorthand for [cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]` { it.`[name][org.jetbrains.kotlinx.dataframe.DataColumn.name]`.`[endsWith][String.endsWith]`(`[suffix][suffix]`) }`.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColumnNameFiltersColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[nameEndsWith][ColumnsSelectionDsl.nameEndsWith]`("order") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "someGroupCol".`[colsNameEndsWith][String.colsNameEndsWith]`("b") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { Type::someGroupCol.`[colsNameEndsWith][SingleColumn.colsNameEndsWith]`("a", ignoreCase = true) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][DataFrame.select]`  {  `[nameEndsWith][ColumnsSelectionDsl.nameEndsWith]`("-order") }`
+     *
+     * @param [suffix] Columns ending with this [suffix] in their name will be returned.
+     * @param [ignoreCase] `true` to ignore character case when comparing strings. By default `false`.
+     *
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing
+     *   all columns ending with [suffix] in their name.
+     * @see [nameStartsWith]
+     * @see [nameContains]
+     */
+    public fun ColumnsSelectionDsl<*>.nameEndsWith(
+        suffix: CharSequence,
+        ignoreCase: Boolean = false,
+    ): TransformableColumnSet<*> = asSingleColumn().colsNameEndsWith(suffix, ignoreCase)
+
+    /**
+     * ## (Cols) Name Ends With
+     * Returns a [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns from [this]
+     * ending with [suffix] in their name.
+     *
+     * This function operates solely on columns at the top-level.
+     *
+     * NOTE: For [column groups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup], the function is named `colsNameEndsWith` to avoid confusion.
+     *
+     * This function is a shorthand for [cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]` { it.`[name][org.jetbrains.kotlinx.dataframe.DataColumn.name]`.`[endsWith][String.endsWith]`(`[suffix][suffix]`) }`.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColumnNameFiltersColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[nameEndsWith][ColumnsSelectionDsl.nameEndsWith]`("order") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "someGroupCol".`[colsNameEndsWith][String.colsNameEndsWith]`("b") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { Type::someGroupCol.`[colsNameEndsWith][SingleColumn.colsNameEndsWith]`("a", ignoreCase = true) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][DataFrame.select]` { someGroupCol.`[colsNameEndsWith][SingleColumn.colsNameEndsWith]`("-order") }`
+     *
+     * @param [suffix] Columns ending with this [suffix] in their name will be returned.
+     * @param [ignoreCase] `true` to ignore character case when comparing strings. By default `false`.
+     *
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing
+     *   all columns ending with [suffix] in their name.
+     * @see [nameStartsWith]
+     * @see [nameContains]
+     */
+    public fun SingleColumn<DataRow<*>>.colsNameEndsWith(
+        suffix: CharSequence,
+        ignoreCase: Boolean = false,
+    ): TransformableColumnSet<*> = this.ensureIsColumnGroup().colsInternal { it.name.endsWith(suffix, ignoreCase) }
+
+    /**
+     * ## (Cols) Name Ends With
+     * Returns a [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns from [this]
+     * ending with [suffix] in their name.
+     *
+     * This function operates solely on columns at the top-level.
+     *
+     * NOTE: For [column groups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup], the function is named `colsNameEndsWith` to avoid confusion.
+     *
+     * This function is a shorthand for [cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]` { it.`[name][org.jetbrains.kotlinx.dataframe.DataColumn.name]`.`[endsWith][String.endsWith]`(`[suffix][suffix]`) }`.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColumnNameFiltersColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[nameEndsWith][ColumnsSelectionDsl.nameEndsWith]`("order") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "someGroupCol".`[colsNameEndsWith][String.colsNameEndsWith]`("b") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { Type::someGroupCol.`[colsNameEndsWith][SingleColumn.colsNameEndsWith]`("a", ignoreCase = true) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][DataFrame.select]` { "someGroupCol".`[colsNameEndsWith][String.colsNameEndsWith]`("-order") }`
+     *
+     * @param [suffix] Columns ending with this [suffix] in their name will be returned.
+     * @param [ignoreCase] `true` to ignore character case when comparing strings. By default `false`.
+     *
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing
+     *   all columns ending with [suffix] in their name.
+     * @see [nameStartsWith]
+     * @see [nameContains]
+     */
+    public fun String.colsNameEndsWith(suffix: CharSequence, ignoreCase: Boolean = false): TransformableColumnSet<*> =
+        columnGroup(this).colsNameEndsWith(suffix, ignoreCase)
+
+    /**
+     * ## (Cols) Name Ends With
+     * Returns a [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns from [this]
+     * ending with [suffix] in their name.
+     *
+     * This function operates solely on columns at the top-level.
+     *
+     * NOTE: For [column groups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup], the function is named `colsNameEndsWith` to avoid confusion.
+     *
+     * This function is a shorthand for [cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]` { it.`[name][org.jetbrains.kotlinx.dataframe.DataColumn.name]`.`[endsWith][String.endsWith]`(`[suffix][suffix]`) }`.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColumnNameFiltersColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[nameEndsWith][ColumnsSelectionDsl.nameEndsWith]`("order") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "someGroupCol".`[colsNameEndsWith][String.colsNameEndsWith]`("b") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { Type::someGroupCol.`[colsNameEndsWith][SingleColumn.colsNameEndsWith]`("a", ignoreCase = true) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][DataFrame.select]` { DataSchemaType::someGroupCol.`[colsNameEndsWith][KProperty.colsNameEndsWith]`("-order") }`
+     *
+     * @param [suffix] Columns ending with this [suffix] in their name will be returned.
+     * @param [ignoreCase] `true` to ignore character case when comparing strings. By default `false`.
+     *
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing
+     *   all columns ending with [suffix] in their name.
+     * @see [nameStartsWith]
+     * @see [nameContains]
+     */
+    public fun KProperty<*>.colsNameEndsWith(
+        suffix: CharSequence,
+        ignoreCase: Boolean = false,
+    ): TransformableColumnSet<*> = columnGroup(this).colsNameEndsWith(suffix, ignoreCase)
+
+    /**
+     * ## (Cols) Name Ends With
+     * Returns a [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns from [this]
+     * ending with [suffix] in their name.
+     *
+     * This function operates solely on columns at the top-level.
+     *
+     * NOTE: For [column groups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup], the function is named `colsNameEndsWith` to avoid confusion.
+     *
+     * This function is a shorthand for [cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]` { it.`[name][org.jetbrains.kotlinx.dataframe.DataColumn.name]`.`[endsWith][String.endsWith]`(`[suffix][suffix]`) }`.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColumnNameFiltersColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[nameEndsWith][ColumnsSelectionDsl.nameEndsWith]`("order") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "someGroupCol".`[colsNameEndsWith][String.colsNameEndsWith]`("b") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { Type::someGroupCol.`[colsNameEndsWith][SingleColumn.colsNameEndsWith]`("a", ignoreCase = true) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][DataFrame.select]` { "pathTo"["someGroupCol"].`[colsNameEndsWith][ColumnPath.colsNameEndsWith]`("-order") }`
+     *
+     * @param [suffix] Columns ending with this [suffix] in their name will be returned.
+     * @param [ignoreCase] `true` to ignore character case when comparing strings. By default `false`.
+     *
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing
+     *   all columns ending with [suffix] in their name.
+     * @see [nameStartsWith]
+     * @see [nameContains]
+     */
+    public fun ColumnPath.colsNameEndsWith(
+        suffix: CharSequence,
+        ignoreCase: Boolean = false,
+    ): TransformableColumnSet<*> = columnGroup(this).colsNameEndsWith(suffix, ignoreCase)
+
+    // endregion
+}
+
+// endregion
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/columnRange.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/columnRange.kt
new file mode 100644
index 000000000..ea63669d0
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/columnRange.kt
@@ -0,0 +1,325 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import org.jetbrains.kotlinx.dataframe.AnyColumnReference
+import org.jetbrains.kotlinx.dataframe.api.ColumnRangeColumnsSelectionDsl.Grammar
+import org.jetbrains.kotlinx.dataframe.columns.ColumnReference
+import org.jetbrains.kotlinx.dataframe.columns.ColumnSet
+import org.jetbrains.kotlinx.dataframe.impl.columns.addPath
+import org.jetbrains.kotlinx.dataframe.impl.columns.createColumnSet
+import kotlin.reflect.KProperty
+
+// region ColumnsSelectionDsl
+
+/**
+ * ## Range of Columns [Columns Selection DSL][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl]
+ *
+ * See [Grammar] for all functions in this interface.
+ */
+public interface ColumnRangeColumnsSelectionDsl {
+
+    /**
+     * ## Range of Columns Grammar
+     *
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * [(What is this notation?)][org.jetbrains.kotlinx.dataframe.documentation.DslGrammar]
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  ### Definitions:
+     *  `column: `[`ColumnAccessor`][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor]`  |  `[`String`][String]`  | `[`KProperty`][kotlin.reflect.KProperty]`<*> | `[`ColumnPath`][org.jetbrains.kotlinx.dataframe.columns.ColumnPath]
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  ### What can be called directly in the [Columns Selection DSL][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl]:
+     *
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  [`column`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ColumnDef]` `[**`..`**][org.jetbrains.kotlinx.dataframe.api.ColumnRangeColumnsSelectionDsl.rangeTo]` `[`column`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ColumnDef]
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     */
+    public interface Grammar {
+
+        /** [**`..`**][ColumnsSelectionDsl.rangeTo] */
+        public interface PlainDslName
+    }
+
+    /**
+     * ## Range of Columns
+     * Creates a [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns from [this] up to (and including) [endInclusive].
+     *
+     * Columns inside column groups are also supported (as long as they share the same direct parent),
+     * as well as any combination of [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi].
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColumnRangeColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `<code>`"fromColumn"`[`..`][String.rangeTo]`"toColumn"`</code>` }`
+     *
+     * @param [endInclusive] The last column in the subset.
+     * @receiver The first column in the subset.
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns from [this] to [endInclusive].
+     * @throws [IllegalArgumentException] if the columns have different parents or the end column is before the
+     *   start column.
+     * @see [ColumnsSelectionDsl.allBefore]
+     * @see [ColumnsSelectionDsl.allAfter]
+     * @see [ColumnsSelectionDsl.allFrom]
+     * @see [ColumnsSelectionDsl.allUpTo]
+     *
+     */
+    public operator fun String.rangeTo(endInclusive: String): ColumnSet<*> =
+        toColumnAccessor().rangeTo(endInclusive.toColumnAccessor())
+
+    /**
+     * ## Range of Columns
+     * Creates a [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns from [this] up to (and including) [endInclusive].
+     *
+     * Columns inside column groups are also supported (as long as they share the same direct parent),
+     * as well as any combination of [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi].
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColumnRangeColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `<code>`"fromColumn"`[`..`][String.rangeTo]`Type::toColumn`</code>` }`
+     *
+     * @param [endInclusive] The last column in the subset.
+     * @receiver The first column in the subset.
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns from [this] to [endInclusive].
+     * @throws [IllegalArgumentException] if the columns have different parents or the end column is before the
+     *   start column.
+     * @see [ColumnsSelectionDsl.allBefore]
+     * @see [ColumnsSelectionDsl.allAfter]
+     * @see [ColumnsSelectionDsl.allFrom]
+     * @see [ColumnsSelectionDsl.allUpTo]
+     *
+     */
+    public operator fun String.rangeTo(endInclusive: KProperty<*>): ColumnSet<*> =
+        toColumnAccessor().rangeTo(endInclusive.toColumnAccessor())
+
+    /**
+     * ## Range of Columns
+     * Creates a [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns from [this] up to (and including) [endInclusive].
+     *
+     * Columns inside column groups are also supported (as long as they share the same direct parent),
+     * as well as any combination of [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi].
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColumnRangeColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `<code>`"fromColumn"`[`..`][String.rangeTo]`toColumn`</code>` }`
+     *
+     * @param [endInclusive] The last column in the subset.
+     * @receiver The first column in the subset.
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns from [this] to [endInclusive].
+     * @throws [IllegalArgumentException] if the columns have different parents or the end column is before the
+     *   start column.
+     * @see [ColumnsSelectionDsl.allBefore]
+     * @see [ColumnsSelectionDsl.allAfter]
+     * @see [ColumnsSelectionDsl.allFrom]
+     * @see [ColumnsSelectionDsl.allUpTo]
+     *
+     */
+    public operator fun String.rangeTo(endInclusive: AnyColumnReference): ColumnSet<*> =
+        toColumnAccessor().rangeTo(endInclusive)
+
+    /**
+     * ## Range of Columns
+     * Creates a [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns from [this] up to (and including) [endInclusive].
+     *
+     * Columns inside column groups are also supported (as long as they share the same direct parent),
+     * as well as any combination of [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi].
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColumnRangeColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `<code>`Type::fromColumn`[`..`][KProperty.rangeTo]`"toColumn"`</code>` }`
+     *
+     * @param [endInclusive] The last column in the subset.
+     * @receiver The first column in the subset.
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns from [this] to [endInclusive].
+     * @throws [IllegalArgumentException] if the columns have different parents or the end column is before the
+     *   start column.
+     * @see [ColumnsSelectionDsl.allBefore]
+     * @see [ColumnsSelectionDsl.allAfter]
+     * @see [ColumnsSelectionDsl.allFrom]
+     * @see [ColumnsSelectionDsl.allUpTo]
+     *
+     */
+    public operator fun KProperty<*>.rangeTo(endInclusive: String): ColumnSet<*> =
+        toColumnAccessor().rangeTo(endInclusive.toColumnAccessor())
+
+    /**
+     * ## Range of Columns
+     * Creates a [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns from [this] up to (and including) [endInclusive].
+     *
+     * Columns inside column groups are also supported (as long as they share the same direct parent),
+     * as well as any combination of [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi].
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColumnRangeColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `<code>`Type::fromColumn`[`..`][KProperty.rangeTo]`Type::toColumn`</code>` }`
+     *
+     * @param [endInclusive] The last column in the subset.
+     * @receiver The first column in the subset.
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns from [this] to [endInclusive].
+     * @throws [IllegalArgumentException] if the columns have different parents or the end column is before the
+     *   start column.
+     * @see [ColumnsSelectionDsl.allBefore]
+     * @see [ColumnsSelectionDsl.allAfter]
+     * @see [ColumnsSelectionDsl.allFrom]
+     * @see [ColumnsSelectionDsl.allUpTo]
+     *
+     */
+    public operator fun KProperty<*>.rangeTo(endInclusive: KProperty<*>): ColumnSet<*> =
+        toColumnAccessor().rangeTo(endInclusive.toColumnAccessor())
+
+    /**
+     * ## Range of Columns
+     * Creates a [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns from [this] up to (and including) [endInclusive].
+     *
+     * Columns inside column groups are also supported (as long as they share the same direct parent),
+     * as well as any combination of [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi].
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColumnRangeColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `<code>`Type::fromColumn`[`..`][KProperty.rangeTo]`toColumn`</code>` }`
+     *
+     * @param [endInclusive] The last column in the subset.
+     * @receiver The first column in the subset.
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns from [this] to [endInclusive].
+     * @throws [IllegalArgumentException] if the columns have different parents or the end column is before the
+     *   start column.
+     * @see [ColumnsSelectionDsl.allBefore]
+     * @see [ColumnsSelectionDsl.allAfter]
+     * @see [ColumnsSelectionDsl.allFrom]
+     * @see [ColumnsSelectionDsl.allUpTo]
+     *
+     */
+    public operator fun KProperty<*>.rangeTo(endInclusive: AnyColumnReference): ColumnSet<*> =
+        toColumnAccessor().rangeTo(endInclusive)
+
+    /**
+     * ## Range of Columns
+     * Creates a [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns from [this] up to (and including) [endInclusive].
+     *
+     * Columns inside column groups are also supported (as long as they share the same direct parent),
+     * as well as any combination of [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi].
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColumnRangeColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `<code>`fromColumn`[`..`][ColumnReference.rangeTo]`"toColumn"`</code>` }`
+     *
+     * @param [endInclusive] The last column in the subset.
+     * @receiver The first column in the subset.
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns from [this] to [endInclusive].
+     * @throws [IllegalArgumentException] if the columns have different parents or the end column is before the
+     *   start column.
+     * @see [ColumnsSelectionDsl.allBefore]
+     * @see [ColumnsSelectionDsl.allAfter]
+     * @see [ColumnsSelectionDsl.allFrom]
+     * @see [ColumnsSelectionDsl.allUpTo]
+     *
+     */
+    public operator fun AnyColumnReference.rangeTo(endInclusive: String): ColumnSet<*> =
+        rangeTo(endInclusive.toColumnAccessor())
+
+    /**
+     * ## Range of Columns
+     * Creates a [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns from [this] up to (and including) [endInclusive].
+     *
+     * Columns inside column groups are also supported (as long as they share the same direct parent),
+     * as well as any combination of [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi].
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColumnRangeColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `<code>`fromColumn`[`..`][ColumnReference.rangeTo]`Type::toColumn`</code>` }`
+     *
+     * @param [endInclusive] The last column in the subset.
+     * @receiver The first column in the subset.
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns from [this] to [endInclusive].
+     * @throws [IllegalArgumentException] if the columns have different parents or the end column is before the
+     *   start column.
+     * @see [ColumnsSelectionDsl.allBefore]
+     * @see [ColumnsSelectionDsl.allAfter]
+     * @see [ColumnsSelectionDsl.allFrom]
+     * @see [ColumnsSelectionDsl.allUpTo]
+     *
+     */
+    public operator fun AnyColumnReference.rangeTo(endInclusive: KProperty<*>): ColumnSet<*> =
+        rangeTo(endInclusive.toColumnAccessor())
+
+    /**
+     * ## Range of Columns
+     * Creates a [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns from [this] up to (and including) [endInclusive].
+     *
+     * Columns inside column groups are also supported (as long as they share the same direct parent),
+     * as well as any combination of [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi].
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ColumnRangeColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `<code>`fromColumn`[`..`][ColumnReference.rangeTo]`toColumn`</code>` }`
+     *
+     * @param [endInclusive] The last column in the subset.
+     * @receiver The first column in the subset.
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing all columns from [this] to [endInclusive].
+     * @throws [IllegalArgumentException] if the columns have different parents or the end column is before the
+     *   start column.
+     * @see [ColumnsSelectionDsl.allBefore]
+     * @see [ColumnsSelectionDsl.allAfter]
+     * @see [ColumnsSelectionDsl.allFrom]
+     * @see [ColumnsSelectionDsl.allUpTo]
+     *
+     */
+    public operator fun AnyColumnReference.rangeTo(endInclusive: AnyColumnReference): ColumnSet<*> =
+        createColumnSet { context ->
+            val startPath = this@rangeTo.resolveSingle(context)!!.path
+            val endPath = endInclusive.resolveSingle(context)!!.path
+            val parentPath = startPath.parent()
+            val parentEndPath = endPath.parent()
+            require(parentPath == parentEndPath) {
+                "Start and end columns have different parent column paths: $parentPath and $parentEndPath"
+            }
+            val parentCol = context.df.getColumnGroup(parentPath!!)
+            val startIndex = parentCol.getColumnIndex(startPath.name)
+            val endIndex = parentCol.getColumnIndex(endPath.name)
+
+            require(startIndex <= endIndex) { "End column is before start column" }
+
+            (startIndex..endIndex).map {
+                parentCol.getColumn(it).let {
+                    it.addPath(parentPath + it.name)
+                }
+            }
+        }
+}
+
+// endregion
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/concat.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/concat.kt
new file mode 100644
index 000000000..ced0b784a
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/concat.kt
@@ -0,0 +1,59 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import org.jetbrains.kotlinx.dataframe.DataColumn
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.DataRow
+import org.jetbrains.kotlinx.dataframe.columns.values
+import org.jetbrains.kotlinx.dataframe.impl.api.concatImpl
+import org.jetbrains.kotlinx.dataframe.impl.asList
+
+// region DataColumn
+
+public fun <T> DataColumn<T>.concat(vararg other: DataColumn<T>): DataColumn<T> = concatImpl(name, listOf(this) + other)
+
+public fun <T> DataColumn<DataFrame<T>>.concat(): DataFrame<T> = values.concat()
+
+public fun <T> DataColumn<Collection<T>>.concat(): List<T> = values.flatten()
+
+// endregion
+
+// region DataRow
+
+public fun <T> DataRow<T>.concat(vararg rows: DataRow<T>): DataFrame<T> = (listOf(this) + rows).concat()
+
+// endregion
+
+// region DataFrame
+
+public fun <T> DataFrame<T>.concat(vararg frames: DataFrame<T>): DataFrame<T> = concatImpl(listOf(this) + frames)
+
+public infix fun <T> DataFrame<T>.concat(frame: DataFrame<T>): DataFrame<T> = concatImpl(listOf(this) + frame)
+
+@JvmName("concatT")
+public fun <T> DataFrame<T>.concat(rows: Iterable<DataRow<T>>): DataFrame<T> = (rows() + rows).concat()
+
+public fun <T> DataFrame<T>.concat(frames: Iterable<DataFrame<T>>): DataFrame<T> = (listOf(this) + frames).concat()
+
+// endregion
+
+// region GroupBy
+
+public fun <T, G> GroupBy<T, G>.concat(): DataFrame<G> = groups.concat()
+
+// endregion
+
+// region Iterable
+
+public fun <T> Iterable<DataFrame<T>>.concat(): DataFrame<T> = concatImpl(asList())
+
+public fun <T> Iterable<DataColumn<T>>.concat(): DataColumn<T> {
+    val list = asList()
+    if (list.isEmpty()) return DataColumn.empty().cast()
+    return concatImpl(list[0].name(), list)
+}
+
+@JvmName("concatRows")
+public fun <T> Iterable<DataRow<T>?>.concat(): DataFrame<T> =
+    concatImpl(map { it?.toDataFrame() ?: DataFrame.empty(1).cast() })
+
+// endregion
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/constructors.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/constructors.kt
new file mode 100644
index 000000000..fbd77787b
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/constructors.kt
@@ -0,0 +1,431 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import org.jetbrains.kotlinx.dataframe.AnyBaseCol
+import org.jetbrains.kotlinx.dataframe.AnyCol
+import org.jetbrains.kotlinx.dataframe.AnyFrame
+import org.jetbrains.kotlinx.dataframe.AnyRow
+import org.jetbrains.kotlinx.dataframe.ColumnGroupReference
+import org.jetbrains.kotlinx.dataframe.DataColumn
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.DataRow
+import org.jetbrains.kotlinx.dataframe.RowExpression
+import org.jetbrains.kotlinx.dataframe.annotations.Interpretable
+import org.jetbrains.kotlinx.dataframe.annotations.Refine
+import org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor
+import org.jetbrains.kotlinx.dataframe.columns.ColumnPath
+import org.jetbrains.kotlinx.dataframe.columns.ColumnReference
+import org.jetbrains.kotlinx.dataframe.columns.FrameColumn
+import org.jetbrains.kotlinx.dataframe.exceptions.DuplicateColumnNamesException
+import org.jetbrains.kotlinx.dataframe.exceptions.UnequalColumnSizesException
+import org.jetbrains.kotlinx.dataframe.impl.ColumnNameGenerator
+import org.jetbrains.kotlinx.dataframe.impl.DataFrameImpl
+import org.jetbrains.kotlinx.dataframe.impl.UNNAMED_COLUMN_PREFIX
+import org.jetbrains.kotlinx.dataframe.impl.api.withValuesImpl
+import org.jetbrains.kotlinx.dataframe.impl.asList
+import org.jetbrains.kotlinx.dataframe.impl.columnName
+import org.jetbrains.kotlinx.dataframe.impl.columns.ColumnAccessorImpl
+import org.jetbrains.kotlinx.dataframe.impl.columns.createColumn
+import org.jetbrains.kotlinx.dataframe.impl.columns.createComputedColumnReference
+import org.jetbrains.kotlinx.dataframe.impl.columns.forceResolve
+import org.jetbrains.kotlinx.dataframe.impl.columns.unbox
+import org.jetbrains.kotlinx.dataframe.size
+import kotlin.random.Random
+import kotlin.random.nextInt
+import kotlin.reflect.KProperty
+import kotlin.reflect.full.withNullability
+import kotlin.reflect.typeOf
+
+// region create ColumnAccessor
+
+// region column
+
+public fun <T> column(): ColumnDelegate<T> = ColumnDelegate()
+
+public fun <T> column(name: String): ColumnAccessor<T> = ColumnAccessorImpl(name)
+
+public fun <T> column(path: ColumnPath): ColumnAccessor<T> = ColumnAccessorImpl(path)
+
+public fun <T> column(property: KProperty<T>): ColumnAccessor<T> = ColumnAccessorImpl(property.name)
+
+public fun <T> ColumnGroupReference.column(): ColumnDelegate<T> = ColumnDelegate(this)
+
+public fun <T> ColumnGroupReference.column(name: String): ColumnAccessor<T> = ColumnAccessorImpl(path() + name)
+
+public fun <T> ColumnGroupReference.column(path: ColumnPath): ColumnAccessor<T> = ColumnAccessorImpl(this.path() + path)
+
+public fun <T> ColumnGroupReference.column(property: KProperty<T>): ColumnAccessor<T> =
+    ColumnAccessorImpl(this.path() + property.name)
+
+public inline fun <reified T> column(
+    name: String = "",
+    infer: Infer = Infer.Nulls,
+    noinline expression: RowExpression<Any?, T>,
+): ColumnReference<T> = createComputedColumnReference(name, typeOf<T>(), infer, expression)
+
+@Suppress("UNCHECKED_CAST", "UNUSED_PARAMETER")
+public inline fun <T, reified C> column(
+    df: DataFrame<T>,
+    name: String = "",
+    infer: Infer = Infer.Nulls,
+    noinline expression: RowExpression<T, C>,
+): ColumnReference<C> = createComputedColumnReference(name, typeOf<C>(), infer, expression as RowExpression<Any?, C>)
+
+// endregion
+
+// region valueColumn
+
+public fun valueColumn(): ColumnDelegate<Any?> = column()
+
+@JvmName("valueColumnTyped")
+public fun <T> valueColumn(): ColumnDelegate<T> = column()
+
+public fun valueColumn(name: String): ColumnAccessor<Any?> = column(name)
+
+@JvmName("valueColumnTyped")
+public fun <T> valueColumn(name: String): ColumnAccessor<T> = column(name)
+
+public fun valueColumn(path: ColumnPath): ColumnAccessor<Any?> = column(path)
+
+@JvmName("valueColumnTyped")
+public fun <T> valueColumn(path: ColumnPath): ColumnAccessor<T> = column(path)
+
+public fun <T> valueColumn(property: KProperty<T>): ColumnAccessor<T> = column(property.name)
+
+public fun ColumnGroupReference.valueColumn(): ColumnDelegate<Any?> = ColumnDelegate(this)
+
+@JvmName("valueColumnTyped")
+public fun <T> ColumnGroupReference.valueColumn(): ColumnDelegate<T> = ColumnDelegate(this)
+
+public fun ColumnGroupReference.valueColumn(name: String): ColumnAccessor<Any?> = ColumnAccessorImpl(path() + name)
+
+@JvmName("valueColumnTyped")
+public fun <T> ColumnGroupReference.valueColumn(name: String): ColumnAccessor<T> = ColumnAccessorImpl(path() + name)
+
+public fun ColumnGroupReference.valueColumn(path: ColumnPath): ColumnAccessor<Any?> =
+    ColumnAccessorImpl(this.path() + path)
+
+@JvmName("valueColumnTyped")
+public fun <T> ColumnGroupReference.valueColumn(path: ColumnPath): ColumnAccessor<T> =
+    ColumnAccessorImpl(this.path() + path)
+
+public fun <T> ColumnGroupReference.valueColumn(property: KProperty<T>): ColumnAccessor<T> =
+    ColumnAccessorImpl(this.path() + property.name)
+
+// endregion
+
+// region columnGroup
+
+public fun columnGroup(): ColumnDelegate<AnyRow> = column()
+
+@JvmName("columnGroupTyped")
+public fun <T> columnGroup(): ColumnDelegate<DataRow<T>> = column()
+
+public fun columnGroup(name: String): ColumnAccessor<AnyRow> = column(name)
+
+@JvmName("columnGroupTyped")
+public fun <T> columnGroup(name: String): ColumnAccessor<DataRow<T>> = column(name)
+
+public fun columnGroup(path: ColumnPath): ColumnAccessor<AnyRow> = column(path)
+
+@JvmName("columnGroupTyped")
+public fun <T> columnGroup(path: ColumnPath): ColumnAccessor<DataRow<T>> = column(path)
+
+@JvmName("columnGroupDataRowKProperty")
+public fun <T> columnGroup(property: KProperty<DataRow<T>>): ColumnAccessor<DataRow<T>> = column(property)
+
+public fun <T> columnGroup(property: KProperty<T>): ColumnAccessor<DataRow<T>> = column(property.name)
+
+public fun ColumnGroupReference.columnGroup(): ColumnDelegate<AnyRow> = ColumnDelegate(this)
+
+@JvmName("columnGroupTyped")
+public fun <T> ColumnGroupReference.columnGroup(): ColumnDelegate<DataRow<T>> = ColumnDelegate(this)
+
+public fun ColumnGroupReference.columnGroup(name: String): ColumnAccessor<AnyRow> = ColumnAccessorImpl(path() + name)
+
+@JvmName("columnGroupTyped")
+public fun <T> ColumnGroupReference.columnGroup(name: String): ColumnAccessor<DataRow<T>> =
+    ColumnAccessorImpl(path() + name)
+
+public fun ColumnGroupReference.columnGroup(path: ColumnPath): ColumnAccessor<AnyRow> =
+    ColumnAccessorImpl(this.path() + path)
+
+@JvmName("columnGroupTyped")
+public fun <T> ColumnGroupReference.columnGroup(path: ColumnPath): ColumnAccessor<DataRow<T>> =
+    ColumnAccessorImpl(this.path() + path)
+
+@JvmName("columnGroupDataRowKProperty")
+public fun <T> ColumnGroupReference.columnGroup(property: KProperty<DataRow<T>>): ColumnAccessor<DataRow<T>> =
+    ColumnAccessorImpl(this.path() + property.name)
+
+public fun <T> ColumnGroupReference.columnGroup(property: KProperty<T>): ColumnAccessor<DataRow<T>> =
+    ColumnAccessorImpl(this.path() + property.name)
+
+// endregion
+
+// region frameColumn
+
+public fun frameColumn(): ColumnDelegate<AnyFrame> = column()
+
+@JvmName("frameColumnTyped")
+public fun <T> frameColumn(): ColumnDelegate<DataFrame<T>> = column()
+
+public fun frameColumn(name: String): ColumnAccessor<AnyFrame> = column(name)
+
+@JvmName("frameColumnTyped")
+public fun <T> frameColumn(name: String): ColumnAccessor<DataFrame<T>> = column(name)
+
+public fun frameColumn(path: ColumnPath): ColumnAccessor<AnyFrame> = column(path)
+
+@JvmName("frameColumnTyped")
+public fun <T> frameColumn(path: ColumnPath): ColumnAccessor<DataFrame<T>> = column(path)
+
+@JvmName("frameColumnDataFrameKProperty")
+public fun <T> frameColumn(property: KProperty<DataFrame<T>>): ColumnAccessor<DataFrame<T>> = column(property)
+
+public fun <T> frameColumn(property: KProperty<List<T>>): ColumnAccessor<DataFrame<T>> = column(property.name)
+
+public fun ColumnGroupReference.frameColumn(): ColumnDelegate<AnyFrame> = ColumnDelegate(this)
+
+@JvmName("frameColumnTyped")
+public fun <T> ColumnGroupReference.frameColumn(): ColumnDelegate<DataFrame<T>> = ColumnDelegate(this)
+
+public fun ColumnGroupReference.frameColumn(name: String): ColumnAccessor<AnyFrame> = ColumnAccessorImpl(path() + name)
+
+@JvmName("frameColumnTyped")
+public fun <T> ColumnGroupReference.frameColumn(name: String): ColumnAccessor<DataFrame<T>> =
+    ColumnAccessorImpl(path() + name)
+
+public fun ColumnGroupReference.frameColumn(path: ColumnPath): ColumnAccessor<AnyFrame> =
+    ColumnAccessorImpl(this.path() + path)
+
+@JvmName("frameColumnTyped")
+public fun <T> ColumnGroupReference.frameColumn(path: ColumnPath): ColumnAccessor<DataFrame<T>> =
+    ColumnAccessorImpl(this.path() + path)
+
+@JvmName("frameColumnDataFrameKProperty")
+public fun <T> ColumnGroupReference.frameColumn(property: KProperty<DataFrame<T>>): ColumnAccessor<DataFrame<T>> =
+    ColumnAccessorImpl(this.path() + property.name)
+
+public fun <T> ColumnGroupReference.frameColumn(property: KProperty<List<T>>): ColumnAccessor<DataFrame<T>> =
+    ColumnAccessorImpl(this.path() + property.name)
+
+// endregion
+
+public class ColumnDelegate<T>(private val parent: ColumnGroupReference? = null) {
+    public operator fun getValue(thisRef: Any?, property: KProperty<*>): ColumnAccessor<T> = named(property.columnName)
+
+    public infix fun named(name: String): ColumnAccessor<T> =
+        parent?.let { ColumnAccessorImpl(it.path() + name) } ?: ColumnAccessorImpl(name)
+}
+
+// endregion
+
+// region create DataColumn
+
+public inline fun <reified T> columnOf(vararg values: T): DataColumn<T> =
+    createColumn(values.asIterable(), typeOf<T>(), true).forceResolve()
+
+public fun columnOf(vararg values: AnyBaseCol): DataColumn<AnyRow> = columnOf(values.asIterable()).forceResolve()
+
+public fun <T> columnOf(vararg frames: DataFrame<T>): FrameColumn<T> = columnOf(frames.asIterable()).forceResolve()
+
+public fun columnOf(columns: Iterable<AnyBaseCol>): DataColumn<AnyRow> =
+    DataColumn.createColumnGroup(
+        name = "",
+        df = dataFrameOf(columns),
+    )
+        .asDataColumn()
+        .forceResolve()
+
+public fun <T> columnOf(frames: Iterable<DataFrame<T>>): FrameColumn<T> =
+    DataColumn.createFrameColumn(
+        name = "",
+        groups = frames.toList(),
+    ).forceResolve()
+
+public inline fun <reified T> column(values: Iterable<T>): DataColumn<T> =
+    createColumn(values, typeOf<T>(), false).forceResolve()
+
+// endregion
+
+// region create DataFrame
+
+/**
+ * Creates new [DataFrame] with given [columns]
+ *
+ * All named columns must have unique names. For columns with empty names unique column names are generated: "untitled", "untitiled1", "untitled2" etc.
+ *
+ * All columns must have equal sizes.
+ *
+ * @throws [DuplicateColumnNamesException] if column names are not unique
+ * @throws [UnequalColumnSizesException] if column size are not equal
+ * @param columns columns for [DataFrame]
+ */
+public fun dataFrameOf(columns: Iterable<AnyBaseCol>): DataFrame<*> {
+    val cols = columns.map { it.unbox() }
+    val nrow = if (cols.isEmpty()) 0 else cols[0].size
+    return DataFrameImpl<Unit>(cols, nrow)
+}
+
+public fun dataFrameOf(vararg header: ColumnReference<*>): DataFrameBuilder = DataFrameBuilder(header.map { it.name() })
+
+public fun dataFrameOf(vararg columns: AnyBaseCol): DataFrame<*> = dataFrameOf(columns.asIterable())
+
+@Interpretable("DataFrameOf0")
+public fun dataFrameOf(vararg header: String): DataFrameBuilder = dataFrameOf(header.toList())
+
+public inline fun <reified C> dataFrameOf(vararg header: String, fill: (String) -> Iterable<C>): DataFrame<*> =
+    dataFrameOf(header.asIterable(), fill)
+
+public fun dataFrameOf(header: Iterable<String>): DataFrameBuilder = DataFrameBuilder(header.asList())
+
+@Refine
+@Interpretable("DataFrameOf3")
+public fun dataFrameOf(vararg columns: Pair<String, List<Any?>>): DataFrame<*> =
+    columns.map { it.second.toColumn(it.first, Infer.Type) }.toDataFrame()
+
+public fun dataFrameOf(header: Iterable<String>, values: Iterable<Any?>): DataFrame<*> =
+    dataFrameOf(header).withValues(values)
+
+public inline fun <T, reified C> dataFrameOf(header: Iterable<T>, fill: (T) -> Iterable<C>): DataFrame<*> =
+    header.map { value ->
+        fill(value).asList().let {
+            DataColumn.create(value.toString(), it)
+        }
+    }.toDataFrame()
+
+public fun dataFrameOf(header: CharProgression): DataFrameBuilder = dataFrameOf(header.map { it.toString() })
+
+public class DataFrameBuilder(private val header: List<String>) {
+
+    public operator fun invoke(vararg columns: AnyCol): DataFrame<*> = invoke(columns.asIterable())
+
+    public operator fun invoke(columns: Iterable<AnyCol>): DataFrame<*> {
+        val cols = columns.asList()
+        require(cols.size == header.size) { "Number of columns differs from number of column names" }
+        return cols.mapIndexed { i, col ->
+            col.rename(header[i])
+        }.toDataFrame()
+    }
+
+    @Refine
+    @Interpretable("DataFrameBuilderInvoke0")
+    public operator fun invoke(vararg values: Any?): DataFrame<*> = withValues(values.asIterable())
+
+    @JvmName("invoke1")
+    internal fun withValues(values: Iterable<Any?>): DataFrame<*> =
+        withValuesImpl(header, values.asList()).map { (name, values) ->
+            DataColumn.createWithTypeInference(name, values)
+        }.toDataFrame()
+
+    public operator fun invoke(args: Sequence<Any?>): DataFrame<*> = invoke(*args.toList().toTypedArray())
+
+    public fun withColumns(columnBuilder: (String) -> AnyCol): DataFrame<*> = header.map(columnBuilder).toDataFrame()
+
+    public inline operator fun <reified T> invoke(crossinline valuesBuilder: (String) -> Iterable<T>): DataFrame<*> =
+        withColumns { name ->
+            valuesBuilder(name).let {
+                DataColumn.create(
+                    name = name,
+                    values = it.asList(),
+                )
+            }
+        }
+
+    public inline fun <reified C> fill(nrow: Int, value: C): DataFrame<*> =
+        withColumns { name ->
+            DataColumn.createValueColumn(
+                name = name,
+                values = List(nrow) { value },
+                type = typeOf<C>().withNullability(value == null),
+            )
+        }
+
+    public inline fun <reified C> nulls(nrow: Int): DataFrame<*> = fill<C?>(nrow, null)
+
+    public inline fun <reified C> fillIndexed(nrow: Int, crossinline init: (Int, String) -> C): DataFrame<*> =
+        withColumns { name ->
+            DataColumn.create(
+                name,
+                List(nrow) { init(it, name) },
+            )
+        }
+
+    public inline fun <reified C> fill(nrow: Int, crossinline init: (Int) -> C): DataFrame<*> =
+        withColumns { name ->
+            DataColumn.create(
+                name = name,
+                values = List(nrow, init),
+            )
+        }
+
+    private inline fun <reified C> fillNotNull(nrow: Int, crossinline init: (Int) -> C) =
+        withColumns { name ->
+            DataColumn.createValueColumn(
+                name = name,
+                values = List(nrow, init),
+                type = typeOf<C>(),
+            )
+        }
+
+    public fun randomInt(nrow: Int): DataFrame<*> = fillNotNull(nrow) { Random.nextInt() }
+
+    public fun randomInt(nrow: Int, range: IntRange): DataFrame<*> = fillNotNull(nrow) { Random.nextInt(range) }
+
+    public fun randomDouble(nrow: Int): DataFrame<*> = fillNotNull(nrow) { Random.nextDouble() }
+
+    public fun randomDouble(nrow: Int, range: ClosedRange<Double>): DataFrame<*> =
+        fillNotNull(nrow) { Random.nextDouble(range.start, range.endInclusive) }
+
+    public fun randomFloat(nrow: Int): DataFrame<*> = fillNotNull(nrow) { Random.nextFloat() }
+
+    public fun randomLong(nrow: Int): DataFrame<*> = fillNotNull(nrow) { Random.nextLong() }
+
+    public fun randomLong(nrow: Int, range: ClosedRange<Long>): DataFrame<*> =
+        fillNotNull(nrow) { Random.nextLong(range.start, range.endInclusive) }
+
+    public fun randomBoolean(nrow: Int): DataFrame<*> = fillNotNull(nrow) { Random.nextBoolean() }
+}
+
+/**
+ * Helper class for implementing operations when column names can be potentially duplicated.
+ * For example, operations involving multiple dataframes, computed columns or parsing some third-party data
+ */
+public class DynamicDataFrameBuilder {
+    private var cols: MutableList<AnyCol> = mutableListOf()
+    private val generator = ColumnNameGenerator()
+
+    public fun add(col: AnyCol): String {
+        val uniqueName = if (col.name().isEmpty()) {
+            generator.addUnique(UNNAMED_COLUMN_PREFIX)
+        } else {
+            generator.addUnique(col.name())
+        }
+        val renamed = if (uniqueName != col.name()) {
+            col.rename(uniqueName)
+        } else {
+            col
+        }
+        cols.add(renamed)
+        return uniqueName
+    }
+
+    public fun toDataFrame(): DataFrame<*> = dataFrameOf(cols)
+}
+
+/**
+ * Returns [DataFrame] with no rows and no columns.
+ *
+ * To create [DataFrame] with empty columns or empty rows see [DataFrame.empty]
+ *
+ * @param T schema marker for [DataFrame]
+ */
+public fun <T> emptyDataFrame(): DataFrame<T> = DataFrame.empty().cast()
+
+// endregion
+
+// region create ColumnPath
+
+public fun pathOf(vararg columnNames: String): ColumnPath = ColumnPath(columnNames.asList())
+
+// endregion
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/convert.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/convert.kt
new file mode 100644
index 000000000..aa3aacd82
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/convert.kt
@@ -0,0 +1,489 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import kotlinx.datetime.Instant
+import kotlinx.datetime.LocalDate
+import kotlinx.datetime.LocalDateTime
+import kotlinx.datetime.LocalTime
+import kotlinx.datetime.TimeZone
+import kotlinx.datetime.toLocalDateTime
+import org.jetbrains.kotlinx.dataframe.AnyBaseCol
+import org.jetbrains.kotlinx.dataframe.AnyCol
+import org.jetbrains.kotlinx.dataframe.AnyFrame
+import org.jetbrains.kotlinx.dataframe.ColumnsContainer
+import org.jetbrains.kotlinx.dataframe.ColumnsSelector
+import org.jetbrains.kotlinx.dataframe.DataColumn
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.DataRow
+import org.jetbrains.kotlinx.dataframe.RowColumnExpression
+import org.jetbrains.kotlinx.dataframe.RowValueExpression
+import org.jetbrains.kotlinx.dataframe.annotations.HasSchema
+import org.jetbrains.kotlinx.dataframe.annotations.Interpretable
+import org.jetbrains.kotlinx.dataframe.annotations.Refine
+import org.jetbrains.kotlinx.dataframe.columns.ColumnGroup
+import org.jetbrains.kotlinx.dataframe.columns.ColumnReference
+import org.jetbrains.kotlinx.dataframe.columns.toColumnSet
+import org.jetbrains.kotlinx.dataframe.dataTypes.IFRAME
+import org.jetbrains.kotlinx.dataframe.dataTypes.IMG
+import org.jetbrains.kotlinx.dataframe.exceptions.CellConversionException
+import org.jetbrains.kotlinx.dataframe.exceptions.TypeConversionException
+import org.jetbrains.kotlinx.dataframe.impl.api.Parsers
+import org.jetbrains.kotlinx.dataframe.impl.api.convertRowColumnImpl
+import org.jetbrains.kotlinx.dataframe.impl.api.convertToTypeImpl
+import org.jetbrains.kotlinx.dataframe.impl.api.defaultTimeZone
+import org.jetbrains.kotlinx.dataframe.impl.api.toLocalDate
+import org.jetbrains.kotlinx.dataframe.impl.api.toLocalDateTime
+import org.jetbrains.kotlinx.dataframe.impl.api.toLocalTime
+import org.jetbrains.kotlinx.dataframe.impl.api.withRowCellImpl
+import org.jetbrains.kotlinx.dataframe.impl.headPlusArray
+import org.jetbrains.kotlinx.dataframe.io.toDataFrame
+import org.jetbrains.kotlinx.dataframe.path
+import java.math.BigDecimal
+import java.net.URL
+import java.util.Locale
+import kotlin.reflect.KProperty
+import kotlin.reflect.KType
+import kotlin.reflect.full.isSubtypeOf
+import kotlin.reflect.full.withNullability
+import kotlin.reflect.typeOf
+
+@Interpretable("Convert0")
+public fun <T, C> DataFrame<T>.convert(columns: ColumnsSelector<T, C>): Convert<T, C> = Convert(this, columns)
+
+public fun <T, C> DataFrame<T>.convert(vararg columns: KProperty<C>): Convert<T, C> = convert { columns.toColumnSet() }
+
+@Interpretable("Convert2")
+public fun <T> DataFrame<T>.convert(vararg columns: String): Convert<T, Any?> = convert { columns.toColumnSet() }
+
+public fun <T, C> DataFrame<T>.convert(vararg columns: ColumnReference<C>): Convert<T, C> =
+    convert { columns.toColumnSet() }
+
+public inline fun <T, C, reified R> DataFrame<T>.convert(
+    firstCol: ColumnReference<C>,
+    vararg cols: ColumnReference<C>,
+    infer: Infer = Infer.Nulls,
+    noinline expression: RowValueExpression<T, C, R>,
+): DataFrame<T> = convert(*headPlusArray(firstCol, cols)).with(infer, expression)
+
+public inline fun <T, C, reified R> DataFrame<T>.convert(
+    firstCol: KProperty<C>,
+    vararg cols: KProperty<C>,
+    infer: Infer = Infer.Nulls,
+    noinline expression: RowValueExpression<T, C, R>,
+): DataFrame<T> = convert(*headPlusArray(firstCol, cols)).with(infer, expression)
+
+@Interpretable("Convert6")
+public inline fun <T, reified R> DataFrame<T>.convert(
+    firstCol: String,
+    vararg cols: String,
+    infer: Infer = Infer.Nulls,
+    noinline expression: RowValueExpression<T, Any?, R>,
+): DataFrame<T> = convert(*headPlusArray(firstCol, cols)).with(infer, expression)
+
+public inline fun <T, C, reified R> Convert<T, C?>.notNull(
+    crossinline expression: RowValueExpression<T, C, R>,
+): DataFrame<T> =
+    with {
+        if (it == null) {
+            null
+        } else {
+            expression(this, it)
+        }
+    }
+
+@HasSchema(schemaArg = 0)
+public class Convert<T, out C>(internal val df: DataFrame<T>, internal val columns: ColumnsSelector<T, C>) {
+    public fun <R> cast(): Convert<T, R> = Convert(df, columns as ColumnsSelector<T, R>)
+
+    @Refine
+    @Interpretable("To0")
+    public inline fun <reified D> to(): DataFrame<T> = to(typeOf<D>())
+
+    override fun toString(): String = "Convert(df=$df, columns=$columns)"
+}
+
+public fun <T> Convert<T, *>.to(type: KType): DataFrame<T> = to { it.convertTo(type) }
+
+public fun <T, C> Convert<T, C>.to(columnConverter: DataFrame<T>.(DataColumn<C>) -> AnyBaseCol): DataFrame<T> =
+    df.replace(columns).with { columnConverter(df, it) }
+
+@Interpretable("With0")
+public inline fun <T, C, reified R> Convert<T, C>.with(
+    infer: Infer = Infer.Nulls,
+    noinline rowConverter: RowValueExpression<T, C, R>,
+): DataFrame<T> = withRowCellImpl(typeOf<R>(), infer, rowConverter)
+
+@Refine
+@Interpretable("With0")
+public inline fun <T, C, reified R> Convert<T, C>.with(
+    noinline rowConverter: RowValueExpression<T, C, R>,
+): DataFrame<T> = with(Infer.Nulls, rowConverter)
+
+public fun <T, C, R> Convert<T, DataRow<C>>.asFrame(
+    body: ColumnsContainer<T>.(ColumnGroup<C>) -> DataFrame<R>,
+): DataFrame<T> = to { body(this, it.asColumnGroup()).asColumnGroup(it.name()) }
+
+public inline fun <T, C, reified R> Convert<T, C>.perRowCol(
+    infer: Infer = Infer.Nulls,
+    noinline expression: RowColumnExpression<T, C, R>,
+): DataFrame<T> = convertRowColumnImpl(typeOf<R>(), infer, expression)
+
+public inline fun <reified C> AnyCol.convertTo(): DataColumn<C> = convertTo(typeOf<C>()) as DataColumn<C>
+
+public fun AnyCol.convertTo(newType: KType): AnyCol {
+    val isTypesAreCorrect = this.type().withNullability(true).isSubtypeOf(typeOf<String?>()) &&
+        newType.withNullability(true) == typeOf<Double?>()
+
+    if (isTypesAreCorrect) {
+        return (this as DataColumn<String?>).convertToDouble().setNullable(newType.isMarkedNullable)
+    }
+    return convertToTypeImpl(newType)
+}
+
+@JvmName("convertToLocalDateTimeFromT")
+public fun <T : Any> DataColumn<T>.convertToLocalDateTime(): DataColumn<LocalDateTime> = convertTo()
+
+public fun <T : Any> DataColumn<T?>.convertToLocalDateTime(): DataColumn<LocalDateTime?> = convertTo()
+
+@JvmName("convertToLocalDateFromT")
+public fun <T : Any> DataColumn<T>.convertToLocalDate(): DataColumn<LocalDate> = convertTo()
+
+public fun <T : Any> DataColumn<T?>.convertToLocalDate(): DataColumn<LocalDate?> = convertTo()
+
+@JvmName("convertToLocalTimeFromT")
+public fun <T : Any> DataColumn<T>.convertToLocalTime(): DataColumn<LocalTime> = convertTo()
+
+public fun <T : Any> DataColumn<T?>.convertToLocalTime(): DataColumn<LocalTime?> = convertTo()
+
+@JvmName("convertToByteFromT")
+public fun <T : Any> DataColumn<T>.convertToByte(): DataColumn<Byte> = convertTo()
+
+public fun <T : Any> DataColumn<T?>.convertToByte(): DataColumn<Byte?> = convertTo()
+
+@JvmName("convertToShortFromT")
+public fun <T : Any> DataColumn<T>.convertToShort(): DataColumn<Short> = convertTo()
+
+public fun <T : Any> DataColumn<T?>.convertToShort(): DataColumn<Short?> = convertTo()
+
+@JvmName("convertToIntFromT")
+public fun <T : Any> DataColumn<T>.convertToInt(): DataColumn<Int> = convertTo()
+
+public fun <T : Any> DataColumn<T?>.convertToInt(): DataColumn<Int?> = convertTo()
+
+@JvmName("convertToLongFromT")
+public fun <T : Any> DataColumn<T>.convertToLong(): DataColumn<Long> = convertTo()
+
+public fun <T : Any> DataColumn<T?>.convertToLong(): DataColumn<Long?> = convertTo()
+
+@JvmName("convertToStringFromT")
+public fun <T : Any> DataColumn<T>.convertToString(): DataColumn<String> = convertTo()
+
+public fun <T : Any> DataColumn<T?>.convertToString(): DataColumn<String?> = convertTo()
+
+@JvmName("convertToDoubleFromT")
+public fun <T : Any> DataColumn<T>.convertToDouble(): DataColumn<Double> = convertTo()
+
+public fun <T : Any> DataColumn<T?>.convertToDouble(): DataColumn<Double?> = convertTo()
+
+/**
+ * Parse String column to Double considering locale (number format).
+ * If [locale] parameter is defined, it's number format is used for parsing.
+ * If [locale] parameter is null, the current system locale is used. If column can not be parsed, then POSIX format is used.
+ */
+@JvmName("convertToDoubleFromString")
+public fun DataColumn<String>.convertToDouble(locale: Locale? = null): DataColumn<Double> =
+    this.castToNullable().convertToDouble(locale).castToNotNullable()
+
+/**
+ * Parse String column to Double considering locale (number format).
+ * If [locale] parameter is defined, it's number format is used for parsing.
+ * If [locale] parameter is null, the current system locale is used. If column can not be parsed, then POSIX format is used.
+ */
+@JvmName("convertToDoubleFromStringNullable")
+public fun DataColumn<String?>.convertToDouble(locale: Locale? = null): DataColumn<Double?> {
+    fun applyParser(parser: (String) -> Double?): DataColumn<Double?> {
+        var currentRow = 0
+        try {
+            return mapIndexed { row, value ->
+                currentRow = row
+                value?.let {
+                    parser(value.trim()) ?: throw TypeConversionException(
+                        value = value,
+                        from = typeOf<String>(),
+                        to = typeOf<Double>(),
+                        column = path,
+                    )
+                }
+            }
+        } catch (e: TypeConversionException) {
+            throw CellConversionException(e.value, e.from, e.to, path, currentRow, e)
+        }
+    }
+
+    return if (locale != null) {
+        val explicitParser = Parsers.getDoubleParser(locale)
+        applyParser(explicitParser)
+    } else {
+        try {
+            val defaultParser = Parsers.getDoubleParser()
+            applyParser(defaultParser)
+        } catch (e: TypeConversionException) {
+            val posixParser = Parsers.getDoubleParser(Locale.forLanguageTag("C.UTF-8"))
+            applyParser(posixParser)
+        }
+    }
+}
+
+@JvmName("convertToFloatFromT")
+public fun <T : Any> DataColumn<T>.convertToFloat(): DataColumn<Float> = convertTo()
+
+public fun <T : Any> DataColumn<T?>.convertToFloat(): DataColumn<Float?> = convertTo()
+
+@JvmName("convertToBigDecimalFromT")
+public fun <T : Any> DataColumn<T>.convertToBigDecimal(): DataColumn<BigDecimal> = convertTo()
+
+public fun <T : Any> DataColumn<T?>.convertToBigDecimal(): DataColumn<BigDecimal?> = convertTo()
+
+@JvmName("convertToBooleanFromT")
+public fun <T : Any> DataColumn<T>.convertToBoolean(): DataColumn<Boolean> = convertTo()
+
+public fun <T : Any> DataColumn<T?>.convertToBoolean(): DataColumn<Boolean?> = convertTo()
+
+// region convert URL
+
+public fun <T, R : URL?> Convert<T, R>.toIFrame(
+    border: Boolean = false,
+    width: Int? = null,
+    height: Int? = null,
+): DataFrame<T> = to { it.map { IFRAME(it.toString(), border, width, height) } }
+
+public fun <T, R : URL?> Convert<T, R>.toImg(width: Int? = null, height: Int? = null): DataFrame<T> =
+    to { it.map { IMG(it.toString(), width, height) } }
+
+// endregion
+
+// region toURL
+
+public fun DataColumn<String>.convertToURL(): DataColumn<URL> = map { URL(it) }
+
+@JvmName("convertToURLFromStringNullable")
+public fun DataColumn<String?>.convertToURL(): DataColumn<URL?> = map { it?.let { URL(it) } }
+
+public fun <T, R : String?> Convert<T, R>.toURL(): DataFrame<T> = to { it.convertToURL() }
+
+// endregion
+
+// region toInstant
+
+public fun DataColumn<String>.convertToInstant(): DataColumn<Instant> = map { Instant.parse(it) }
+
+@JvmName("convertToInstantFromStringNullable")
+public fun DataColumn<String?>.convertToInstant(): DataColumn<Instant?> = map { it?.let { Instant.parse(it) } }
+
+public fun <T, R : String?> Convert<T, R>.toInstant(): DataFrame<T> = to { it.convertToInstant() }
+
+// endregion
+
+// region toLocalDate
+
+@JvmName("convertToLocalDateFromLong")
+public fun DataColumn<Long>.convertToLocalDate(zone: TimeZone = defaultTimeZone): DataColumn<LocalDate> =
+    map { it.toLocalDate(zone) }
+
+public fun DataColumn<Long?>.convertToLocalDate(zone: TimeZone = defaultTimeZone): DataColumn<LocalDate?> =
+    map { it?.toLocalDate(zone) }
+
+@JvmName("convertToLocalDateFromInt")
+public fun DataColumn<Int>.convertToLocalDate(zone: TimeZone = defaultTimeZone): DataColumn<LocalDate> =
+    map { it.toLong().toLocalDate(zone) }
+
+@JvmName("convertToLocalDateFromIntNullable")
+public fun DataColumn<Int?>.convertToLocalDate(zone: TimeZone = defaultTimeZone): DataColumn<LocalDate?> =
+    map { it?.toLong()?.toLocalDate(zone) }
+
+@JvmName("convertToLocalDateFromString")
+public fun DataColumn<String>.convertToLocalDate(
+    pattern: String? = null,
+    locale: Locale? = null,
+): DataColumn<LocalDate> {
+    val converter = Parsers.getDateTimeConverter(LocalDate::class, pattern, locale)
+    return map { converter(it.trim()) ?: error("Can't convert `$it` to LocalDate") }
+}
+
+@JvmName("convertToLocalDateFromStringNullable")
+public fun DataColumn<String?>.convertToLocalDate(
+    pattern: String? = null,
+    locale: Locale? = null,
+): DataColumn<LocalDate?> {
+    val converter = Parsers.getDateTimeConverter(LocalDate::class, pattern, locale)
+    return map { it?.let { converter(it.trim()) ?: error("Can't convert `$it` to LocalDate") } }
+}
+
+@JvmName("toLocalDateFromTLong")
+public fun <T, R : Long?> Convert<T, R>.toLocalDate(zone: TimeZone = defaultTimeZone): DataFrame<T> =
+    to { it.convertToLocalDate(zone) }
+
+@JvmName("toLocalDateFromTInt")
+public fun <T, R : Int?> Convert<T, R>.toLocalDate(zone: TimeZone = defaultTimeZone): DataFrame<T> =
+    to { it.convertToLocalDate(zone) }
+
+public fun <T, R : String?> Convert<T, R>.toLocalDate(pattern: String? = null, locale: Locale? = null): DataFrame<T> =
+    to { it.convertToLocalDate(pattern, locale) }
+
+public fun <T> Convert<T, *>.toLocalDate(): DataFrame<T> = to { it.convertTo<LocalDate>() }
+
+// endregion
+
+// region toLocalTime
+
+@JvmName("convertToLocalTimeFromLong")
+public fun DataColumn<Long>.convertToLocalTime(zone: TimeZone = defaultTimeZone): DataColumn<LocalTime> =
+    map { it.toLocalTime(zone) }
+
+public fun DataColumn<Long?>.convertToLocalTime(zone: TimeZone = defaultTimeZone): DataColumn<LocalTime?> =
+    map { it?.toLocalTime(zone) }
+
+@JvmName("convertToLocalTimeFromInt")
+public fun DataColumn<Int>.convertToLocalTime(zone: TimeZone = defaultTimeZone): DataColumn<LocalTime> =
+    map { it.toLong().toLocalTime(zone) }
+
+@JvmName("convertToLocalTimeIntNullable")
+public fun DataColumn<Int?>.convertToLocalTime(zone: TimeZone = defaultTimeZone): DataColumn<LocalTime?> =
+    map { it?.toLong()?.toLocalTime(zone) }
+
+@JvmName("convertToLocalTimeFromString")
+public fun DataColumn<String>.convertToLocalTime(
+    pattern: String? = null,
+    locale: Locale? = null,
+): DataColumn<LocalTime> {
+    val converter = Parsers.getDateTimeConverter(LocalTime::class, pattern, locale)
+    return map { converter(it.trim()) ?: error("Can't convert `$it` to LocalTime") }
+}
+
+@JvmName("convertToLocalTimeFromStringNullable")
+public fun DataColumn<String?>.convertToLocalTime(
+    pattern: String? = null,
+    locale: Locale? = null,
+): DataColumn<LocalTime?> {
+    val converter = Parsers.getDateTimeConverter(LocalTime::class, pattern, locale)
+    return map { it?.let { converter(it.trim()) ?: error("Can't convert `$it` to LocalTime") } }
+}
+
+@JvmName("toLocalTimeFromTLong")
+public fun <T, R : Long?> Convert<T, R>.toLocalTime(zone: TimeZone = defaultTimeZone): DataFrame<T> =
+    to { it.convertToLocalTime(zone) }
+
+@JvmName("toLocalTimeFromTInt")
+public fun <T, R : Int?> Convert<T, R>.toLocalTime(zone: TimeZone = defaultTimeZone): DataFrame<T> =
+    to { it.convertToLocalTime(zone) }
+
+public fun <T, R : String?> Convert<T, R>.toLocalTime(pattern: String? = null, locale: Locale? = null): DataFrame<T> =
+    to { it.convertToLocalTime(pattern, locale) }
+
+public fun <T> Convert<T, *>.toLocalTime(): DataFrame<T> = to { it.convertTo<LocalTime>() }
+
+// endregion
+
+// region toLocalDateTime
+
+@JvmName("convertToLocalDateTimeFromLong")
+public fun DataColumn<Long>.convertToLocalDateTime(zone: TimeZone = defaultTimeZone): DataColumn<LocalDateTime> =
+    map { it.toLocalDateTime(zone) }
+
+public fun DataColumn<Long?>.convertToLocalDateTime(zone: TimeZone = defaultTimeZone): DataColumn<LocalDateTime?> =
+    map { it?.toLocalDateTime(zone) }
+
+@JvmName("convertToLocalDateTimeFromInstant")
+public fun DataColumn<Instant>.convertToLocalDateTime(zone: TimeZone = defaultTimeZone): DataColumn<LocalDateTime> =
+    map { it.toLocalDateTime(zone) }
+
+@JvmName("convertToLocalDateTimeFromInstantNullable")
+public fun DataColumn<Instant?>.convertToLocalDateTime(zone: TimeZone = defaultTimeZone): DataColumn<LocalDateTime?> =
+    map { it?.toLocalDateTime(zone) }
+
+@JvmName("convertToLocalDateTimeFromInt")
+public fun DataColumn<Int>.convertToLocalDateTime(zone: TimeZone = defaultTimeZone): DataColumn<LocalDateTime> =
+    map { it.toLong().toLocalDateTime(zone) }
+
+@JvmName("convertToLocalDateTimeFromIntNullable")
+public fun DataColumn<Int?>.convertToLocalDateTime(zone: TimeZone = defaultTimeZone): DataColumn<LocalDateTime?> =
+    map { it?.toLong()?.toLocalDateTime(zone) }
+
+@JvmName("convertToLocalDateTimeFromString")
+public fun DataColumn<String>.convertToLocalDateTime(
+    pattern: String? = null,
+    locale: Locale? = null,
+): DataColumn<LocalDateTime> {
+    val converter = Parsers.getDateTimeConverter(LocalDateTime::class, pattern, locale)
+    return map { converter(it.trim()) ?: error("Can't convert `$it` to LocalDateTime") }
+}
+
+@JvmName("convertToLocalDateTimeFromStringNullable")
+public fun DataColumn<String?>.convertToLocalDateTime(
+    pattern: String? = null,
+    locale: Locale? = null,
+): DataColumn<LocalDateTime?> {
+    val converter = Parsers.getDateTimeConverter(LocalDateTime::class, pattern, locale)
+    return map { it?.let { converter(it.trim()) ?: error("Can't convert `$it` to LocalDateTime") } }
+}
+
+@JvmName("toLocalDateTimeFromTLong")
+public fun <T, R : Long?> Convert<T, R>.toLocalDateTime(zone: TimeZone = defaultTimeZone): DataFrame<T> =
+    to { it.convertToLocalDateTime(zone) }
+
+@JvmName("toLocalDateTimeFromTInstant")
+public fun <T, R : Instant?> Convert<T, R>.toLocalDateTime(zone: TimeZone = defaultTimeZone): DataFrame<T> =
+    to { it.convertToLocalDateTime(zone) }
+
+@JvmName("toLocalDateTimeFromTInt")
+public fun <T, R : Int?> Convert<T, R>.toLocalDateTime(zone: TimeZone = defaultTimeZone): DataFrame<T> =
+    to { it.convertToLocalDateTime(zone) }
+
+public fun <T, R : String?> Convert<T, R>.toLocalDateTime(
+    pattern: String? = null,
+    locale: Locale? = null,
+): DataFrame<T> = to { it.convertToLocalDateTime(pattern, locale) }
+
+public fun <T> Convert<T, *>.toLocalDateTime(): DataFrame<T> = to { it.convertTo<LocalDateTime>() }
+
+// endregion
+
+@JvmName("toIntTAny")
+public fun <T> Convert<T, Any>.toInt(): DataFrame<T> = to<Int>()
+
+public fun <T> Convert<T, Any?>.toInt(): DataFrame<T> = to<Int?>()
+
+@JvmName("toLongTAny")
+public fun <T> Convert<T, Any>.toLong(): DataFrame<T> = to<Long>()
+
+public fun <T> Convert<T, Any?>.toLong(): DataFrame<T> = to<Long?>()
+
+@JvmName("toStrTAny")
+public fun <T> Convert<T, Any>.toStr(): DataFrame<T> = to<String>()
+
+public fun <T> Convert<T, Any?>.toStr(): DataFrame<T> = to<String?>()
+
+@JvmName("toDoubleTAny")
+public fun <T> Convert<T, Any>.toDouble(): DataFrame<T> = to<Double>()
+
+public fun <T> Convert<T, Any?>.toDouble(): DataFrame<T> = to<Double?>()
+
+@JvmName("toFloatTAny")
+public fun <T> Convert<T, Any>.toFloat(): DataFrame<T> = to<Float>()
+
+public fun <T> Convert<T, Any?>.toFloat(): DataFrame<T> = to<Float?>()
+
+@JvmName("toBigDecimalTAny")
+public fun <T> Convert<T, Any>.toBigDecimal(): DataFrame<T> = to<BigDecimal>()
+
+public fun <T> Convert<T, Any?>.toBigDecimal(): DataFrame<T> = to<BigDecimal?>()
+
+@JvmName("toBooleanTAny")
+public fun <T> Convert<T, Any>.toBoolean(): DataFrame<T> = to<Boolean>()
+
+public fun <T> Convert<T, Any?>.toBoolean(): DataFrame<T> = to<Boolean?>()
+
+public fun <T, C> Convert<T, List<List<C>>>.toDataFrames(containsColumns: Boolean = false): DataFrame<T> =
+    to { it.toDataFrames(containsColumns) }
+
+public fun <T> DataColumn<List<List<T>>>.toDataFrames(containsColumns: Boolean = false): DataColumn<AnyFrame> =
+    map { it.toDataFrame(containsColumns) }
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/convertTo.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/convertTo.kt
new file mode 100644
index 000000000..70f295494
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/convertTo.kt
@@ -0,0 +1,236 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import org.jetbrains.kotlinx.dataframe.AnyFrame
+import org.jetbrains.kotlinx.dataframe.ColumnsSelector
+import org.jetbrains.kotlinx.dataframe.DataColumn
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.RowExpression
+import org.jetbrains.kotlinx.dataframe.exceptions.ColumnNotFoundException
+import org.jetbrains.kotlinx.dataframe.exceptions.ExcessiveColumnsException
+import org.jetbrains.kotlinx.dataframe.exceptions.TypeConversionException
+import org.jetbrains.kotlinx.dataframe.exceptions.TypeConverterNotFoundException
+import org.jetbrains.kotlinx.dataframe.impl.api.ConvertSchemaDslInternal
+import org.jetbrains.kotlinx.dataframe.impl.api.convertToImpl
+import org.jetbrains.kotlinx.dataframe.schema.ColumnSchema
+import kotlin.reflect.KProperty
+import kotlin.reflect.KType
+import kotlin.reflect.typeOf
+
+/**
+ * Specifies how to handle columns in original dataframe that were not matched to any column in destination dataframe schema.
+ */
+public enum class ExcessiveColumns {
+    /**
+     * Remove excessive columns from resulting dataframe
+     */
+    Remove,
+
+    /**
+     * Keep excessive columns in resulting dataframe
+     */
+    Keep,
+
+    /**
+     * Throw [ExcessiveColumnsException] if any excessive columns were found in the original dataframe
+     */
+    Fail,
+}
+
+/**
+ * Holds data context for [fill] operation
+ */
+public data class ConvertToFill<T, C>(internal val dsl: ConvertSchemaDsl<T>, val columns: ColumnsSelector<T, C>)
+
+/** Provides access to [fromType] and [toSchema] in the flexible [ConvertSchemaDsl.convertIf] method. */
+public class ConverterScope(public val fromType: KType, public val toSchema: ColumnSchema)
+
+/**
+ * Dsl to customize column conversion
+ *
+ * Example:
+ * ```kotlin
+ * df.convertTo<SomeSchema> {
+ *     // defines how to convert Int? -> String
+ *     convert<Int?>().with { it?.toString() ?: "No input given" }
+ *     // defines how to convert String -> SomeType
+ *     parser { SomeType(it) }
+ *     // fill missing column `sum` with expression `a+b`
+ *     fill { sum }.with { a + b }
+ * }
+ * ```
+ */
+public interface ConvertSchemaDsl<in T> {
+
+    /**
+     * Defines how to convert [from]: [A] to [to]: [B].
+     *
+     * Note: In most cases using `convert<Type>().with { }` is more convenient, however
+     * if you only have [KType], this method can be used.
+     */
+    public fun <A, B> convert(from: KType, to: KType, converter: (A) -> B)
+
+    /**
+     * Advanced version of [convert].
+     * If you want to define a common conversion for multiple types (or any type), or
+     * you need extra information about the target, such as its schema, use this method.
+     *
+     * The exact type conversion does have higher priority. After that, this flexible conversions will be checked
+     * in order.
+     *
+     * @param condition a function that should return `true` if the conversion should be applied from the given `fromType`
+     *   to the given `toSchema`.
+     * @param converter a function that performs the conversion with access to a [ConverterScope].
+     */
+    public fun convertIf(
+        condition: (fromType: KType, toSchema: ColumnSchema) -> Boolean,
+        converter: ConverterScope.(Any?) -> Any?,
+    )
+}
+
+/**
+ * Defines how to fill specified columns in destination schema that were not found in original dataframe.
+ * All [fill] operations for missing columns are executed after successful conversion of matched columns, so converted values of matched columns can be safely used in [with] expression.
+ * @param columns target columns in destination dataframe schema to be filled
+ */
+public inline fun <T, reified C> ConvertSchemaDsl<T>.fill(
+    noinline columns: ColumnsSelector<T, C>,
+): ConvertToFill<T, C> = ConvertToFill(this, columns)
+
+public fun <T, C> ConvertToFill<T, C>.with(expr: RowExpression<T, C>) {
+    (dsl as ConvertSchemaDslInternal<T>).fill(columns as ColumnsSelector<*, C>, expr as RowExpression<*, C>)
+}
+
+/**
+ * Defines how to convert `String` values into given type [C].
+ */
+public inline fun <reified C> ConvertSchemaDsl<*>.parser(noinline parser: (String) -> C): Unit =
+    convert<String>().with(parser)
+
+/**
+ * Defines how to convert values of given type [C]
+ */
+public inline fun <reified C> ConvertSchemaDsl<*>.convert(): ConvertType<C> = ConvertType(this, typeOf<C>())
+
+/**
+ * Defines how to convert values of type [C] into type [R]
+ */
+public inline fun <C, reified R> ConvertType<C>.with(noinline converter: (C) -> R): Unit =
+    dsl.convert(from, typeOf<R>(), converter)
+
+public class ConvertType<T>(
+    @PublishedApi internal val dsl: ConvertSchemaDsl<*>,
+    @PublishedApi internal val from: KType,
+    internal val property: KProperty<T>? = null,
+)
+
+// region DataFrame
+
+/**
+ * Converts values in [DataFrame] to match given column schema [T].
+ *
+ * Original columns are mapped to destination columns by column [path][DataColumn.path].
+ *
+ * Type converters for every column are selected automatically. See [convert] operation for details.
+ *
+ * To specify custom type converters for the particular types use [ConvertSchemaDsl].
+ *
+ * Example of Dsl:
+ * ```kotlin
+ * df.convertTo<SomeSchema> {
+ *     // defines how to convert Int? -> String
+ *     convert<Int?>().with { it?.toString() ?: "No input given" }
+ *     // defines how to convert String -> SomeType
+ *     parser { SomeType(it) }
+ *     // fill missing column `sum` with expression `a + b`
+ *     fill { sum }.with { a + b }
+ * }
+ * ```
+ *
+ * @param [T] class that defines target schema for conversion.
+ * @param [excessiveColumnsBehavior] how to handle excessive columns in the original [DataFrame].
+ * @param [body] optional dsl to define custom type converters.
+ * @throws [ColumnNotFoundException] if [DataFrame] doesn't contain columns that are required by destination schema.
+ * @throws [ExcessiveColumnsException] if [DataFrame] contains columns that are not required by destination schema and [excessiveColumnsBehavior] is set to [ExcessiveColumns.Fail].
+ * @throws [TypeConverterNotFoundException] if suitable type converter for some column was not found.
+ * @throws [TypeConversionException] if type converter failed to convert column values.
+ * @return converted [DataFrame].
+ */
+public inline fun <reified T : Any> AnyFrame.convertTo(
+    excessiveColumnsBehavior: ExcessiveColumns = ExcessiveColumns.Keep,
+    noinline body: ConvertSchemaDsl<T>.() -> Unit = {},
+): DataFrame<T> = convertToImpl(typeOf<T>(), true, excessiveColumnsBehavior, body).cast()
+
+/**
+ * Converts values in [DataFrame] to match given column schema [T].
+ *
+ * Original columns are mapped to destination columns by column [path][DataColumn.path].
+ *
+ * Type converters for every column are selected automatically. See [convert] operation for details.
+ *
+ * To specify custom type converters for the particular types use [ConvertSchemaDsl].
+ *
+ * Example of Dsl:
+ * ```kotlin
+ * df.convertTo(schemaFrom = sample) {
+ *     // defines how to convert Int? -> String
+ *     convert<Int?>().with { it?.toString() ?: "No input given" }
+ *     // defines how to convert String -> SomeType
+ *     parser { SomeType(it) }
+ *     // fill missing column `sum` with expression `a + b`
+ *     fill { sum }.with { a + b }
+ * }
+ * ```
+ *
+ * @param [T] class that defines target schema for conversion.
+ * @param [schemaFrom] dataframe which type [T] will be used.
+ * @param [excessiveColumnsBehavior] how to handle excessive columns in the original [DataFrame].
+ * @param [body] optional dsl to define custom type converters.
+ * @throws [ColumnNotFoundException] if [DataFrame] doesn't contain columns that are required by destination schema.
+ * @throws [ExcessiveColumnsException] if [DataFrame] contains columns that are not required by destination schema and [excessiveColumnsBehavior] is set to [ExcessiveColumns.Fail].
+ * @throws [TypeConverterNotFoundException] if suitable type converter for some column was not found.
+ * @throws [TypeConversionException] if type converter failed to convert column values.
+ * @return converted [DataFrame].
+ */
+public inline fun <reified T : Any> AnyFrame.convertTo(
+    @Suppress("UNUSED_PARAMETER") schemaFrom: DataFrame<T>,
+    excessiveColumnsBehavior: ExcessiveColumns = ExcessiveColumns.Keep,
+    noinline body: ConvertSchemaDsl<T>.() -> Unit = {},
+): DataFrame<T> = convertToImpl(typeOf<T>(), true, excessiveColumnsBehavior, body).cast()
+
+/**
+ * Converts values in [DataFrame] to match given column schema [schemaType].
+ *
+ * Original columns are mapped to destination columns by column [path][DataColumn.path].
+ *
+ * Type converters for every column are selected automatically. See [convert] operation for details.
+ *
+ * To specify custom type converters for the particular types use [ConvertSchemaDsl].
+ *
+ * Example of Dsl:
+ * ```kotlin
+ * df.convertTo<SomeSchema> {
+ *     // defines how to convert Int? -> String
+ *     convert<Int?>().with { it?.toString() ?: "No input given" }
+ *     // defines how to convert String -> SomeType
+ *     parser { SomeType(it) }
+ *     // fill missing column `sum` with expression `a+b`
+ *     fill { sum }.with { a + b }
+ * }
+ * ```
+ *
+ * @param [schemaType] defines target schema for conversion.
+ * @param [excessiveColumnsBehavior] how to handle excessive columns in the original [DataFrame].
+ * @param [body] optional dsl to define custom type converters.
+ * @throws [ColumnNotFoundException] if [DataFrame] doesn't contain columns that are required by destination schema.
+ * @throws [ExcessiveColumnsException] if [DataFrame] contains columns that are not required by destination schema and [excessiveColumnsBehavior] is set to [ExcessiveColumns.Fail].
+ * @throws [TypeConverterNotFoundException] if suitable type converter for some column was not found.
+ * @throws [TypeConversionException] if type converter failed to convert column values.
+ * @return converted [DataFrame].
+ */
+public fun AnyFrame.convertTo(
+    schemaType: KType,
+    excessiveColumnsBehavior: ExcessiveColumns = ExcessiveColumns.Keep,
+    body: ConvertSchemaDsl<Any>.() -> Unit = {},
+): AnyFrame = convertToImpl(schemaType, true, excessiveColumnsBehavior, body)
+
+// endregion
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/copy.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/copy.kt
new file mode 100644
index 000000000..c0c930a03
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/copy.kt
@@ -0,0 +1,9 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import org.jetbrains.kotlinx.dataframe.DataFrame
+
+// region DataFrame
+
+public fun <T> DataFrame<T>.copy(): DataFrame<T> = columns().toDataFrame().cast()
+
+// endregion
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/corr.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/corr.kt
new file mode 100644
index 000000000..ef84168c9
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/corr.kt
@@ -0,0 +1,40 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import org.jetbrains.kotlinx.dataframe.AnyCol
+import org.jetbrains.kotlinx.dataframe.ColumnsSelector
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.columns.ColumnReference
+import org.jetbrains.kotlinx.dataframe.columns.toColumnSet
+import org.jetbrains.kotlinx.dataframe.impl.api.corrImpl
+import kotlin.reflect.KProperty
+import kotlin.reflect.typeOf
+
+internal fun AnyCol.isSuitableForCorr() = isSubtypeOf<Number>() || type() == typeOf<Boolean>()
+
+// region DataFrame
+
+public data class Corr<T, C>(internal val df: DataFrame<T>, internal val columns: ColumnsSelector<T, C>)
+
+public fun <T> DataFrame<T>.corr(): DataFrame<T> = corr { colsAtAnyDepth { it.isSuitableForCorr() } }.withItself()
+
+public fun <T, C> DataFrame<T>.corr(columns: ColumnsSelector<T, C>): Corr<T, C> = Corr(this, columns)
+
+public fun <T> DataFrame<T>.corr(vararg columns: String): Corr<T, Any?> = corr { columns.toColumnSet() }
+
+public fun <T, C> DataFrame<T>.corr(vararg columns: KProperty<C>): Corr<T, C> = corr { columns.toColumnSet() }
+
+public fun <T, C> DataFrame<T>.corr(vararg columns: ColumnReference<C>): Corr<T, C> = corr { columns.toColumnSet() }
+
+public fun <T, C, R> Corr<T, C>.with(otherColumns: ColumnsSelector<T, R>): DataFrame<T> = corrImpl(otherColumns)
+
+public fun <T, C> Corr<T, C>.with(vararg otherColumns: String): DataFrame<T> = with { otherColumns.toColumnSet() }
+
+public fun <T, C, R> Corr<T, C>.with(vararg otherColumns: KProperty<R>): DataFrame<T> =
+    with { otherColumns.toColumnSet() }
+
+public fun <T, C, R> Corr<T, C>.with(vararg otherColumns: ColumnReference<R>): DataFrame<T> =
+    with { otherColumns.toColumnSet() }
+
+public fun <T, C> Corr<T, C>.withItself(): DataFrame<T> = with(columns)
+
+// endregion
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/count.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/count.kt
new file mode 100644
index 000000000..e8b306338
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/count.kt
@@ -0,0 +1,62 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import org.jetbrains.kotlinx.dataframe.AnyRow
+import org.jetbrains.kotlinx.dataframe.DataColumn
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.DataRow
+import org.jetbrains.kotlinx.dataframe.Predicate
+import org.jetbrains.kotlinx.dataframe.RowFilter
+import org.jetbrains.kotlinx.dataframe.impl.aggregation.modes.aggregateValue
+
+// region DataColumn
+
+public fun <T> DataColumn<T>.count(predicate: Predicate<T>? = null): Int =
+    if (predicate == null) {
+        size()
+    } else {
+        values().count(predicate)
+    }
+
+// endregion
+
+// region DataRow
+
+public fun AnyRow.count(): Int = columnsCount()
+
+public fun AnyRow.count(predicate: Predicate<Any?>): Int = values().count(predicate)
+
+// endregion
+
+// region DataFrame
+
+public fun <T> DataFrame<T>.count(): Int = rowsCount()
+
+public fun <T> DataFrame<T>.count(predicate: RowFilter<T>): Int = rows().count { predicate(it, it) }
+
+// endregion
+
+// region GroupBy
+
+public fun <T> Grouped<T>.count(resultName: String = "count"): DataFrame<T> =
+    aggregateValue(resultName) { count() default 0 }
+
+public fun <T> Grouped<T>.count(resultName: String = "count", predicate: RowFilter<T>): DataFrame<T> =
+    aggregateValue(resultName) { count(predicate) default 0 }
+
+// endregion
+
+// region Pivot
+
+public fun <T> Pivot<T>.count(): DataRow<T> = delegate { count() }
+
+public fun <T> Pivot<T>.count(predicate: RowFilter<T>): DataRow<T> = delegate { count(predicate) }
+
+// endregion
+
+// region PivotGroupBy
+
+public fun <T> PivotGroupBy<T>.count(): DataFrame<T> = aggregate { count() default 0 }
+
+public fun <T> PivotGroupBy<T>.count(predicate: RowFilter<T>): DataFrame<T> = aggregate { count(predicate) default 0 }
+
+// endregion
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/countDistinct.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/countDistinct.kt
new file mode 100644
index 000000000..679d21dd1
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/countDistinct.kt
@@ -0,0 +1,28 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import org.jetbrains.kotlinx.dataframe.AnyColumnReference
+import org.jetbrains.kotlinx.dataframe.AnyFrame
+import org.jetbrains.kotlinx.dataframe.ColumnsSelector
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.columns.toColumnSet
+import org.jetbrains.kotlinx.dataframe.indices
+import kotlin.reflect.KProperty
+
+// region DataFrame
+
+public fun AnyFrame.countDistinct(): Int = countDistinct { all() }
+
+public fun <T, C> DataFrame<T>.countDistinct(columns: ColumnsSelector<T, C>): Int {
+    val cols = get(columns)
+    return indices.distinctBy { i -> cols.map { it[i] } }.size
+}
+
+public fun <T> DataFrame<T>.countDistinct(vararg columns: String): Int = countDistinct { columns.toColumnSet() }
+
+public fun <T, C> DataFrame<T>.countDistinct(vararg columns: KProperty<C>): Int =
+    countDistinct { columns.toColumnSet() }
+
+public fun <T> DataFrame<T>.countDistinct(vararg columns: AnyColumnReference): Int =
+    countDistinct { columns.toColumnSet() }
+
+// endregion
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/cumSum.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/cumSum.kt
new file mode 100644
index 000000000..9d8c7ff71
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/cumSum.kt
@@ -0,0 +1,88 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import org.jetbrains.kotlinx.dataframe.AnyColumnReference
+import org.jetbrains.kotlinx.dataframe.ColumnsSelector
+import org.jetbrains.kotlinx.dataframe.DataColumn
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.columns.toColumnSet
+import org.jetbrains.kotlinx.dataframe.math.cumSum
+import org.jetbrains.kotlinx.dataframe.math.defaultCumSumSkipNA
+import org.jetbrains.kotlinx.dataframe.typeClass
+import java.math.BigDecimal
+import kotlin.reflect.KProperty
+import kotlin.reflect.typeOf
+
+// region DataColumn
+
+public fun <T : Number?> DataColumn<T>.cumSum(skipNA: Boolean = defaultCumSumSkipNA): DataColumn<T> =
+    when (type()) {
+        typeOf<Double>() -> cast<Double>().cumSum(skipNA).cast()
+        typeOf<Double?>() -> cast<Double?>().cumSum(skipNA).cast()
+        typeOf<Float>() -> cast<Float>().cumSum(skipNA).cast()
+        typeOf<Float?>() -> cast<Float?>().cumSum(skipNA).cast()
+        typeOf<Int>() -> cast<Int>().cumSum().cast()
+        typeOf<Int?>() -> cast<Int?>().cumSum(skipNA).cast()
+        typeOf<Long>() -> cast<Long>().cumSum().cast()
+        typeOf<Long?>() -> cast<Long?>().cumSum(skipNA).cast()
+        typeOf<BigDecimal>() -> cast<BigDecimal>().cumSum().cast()
+        typeOf<BigDecimal?>() -> cast<BigDecimal?>().cumSum(skipNA).cast()
+        typeOf<Number?>(), typeOf<Number>() -> convertToDouble().cumSum(skipNA).cast()
+        else -> error("Cumsum for type ${type()} is not supported")
+    }
+
+private val supportedClasses = setOf(Double::class, Float::class, Int::class, Long::class, BigDecimal::class)
+
+// endregion
+
+// region DataFrame
+
+public fun <T, C> DataFrame<T>.cumSum(
+    skipNA: Boolean = defaultCumSumSkipNA,
+    columns: ColumnsSelector<T, C>,
+): DataFrame<T> =
+    convert(columns).to { if (it.typeClass in supportedClasses) it.cast<Number?>().cumSum(skipNA) else it }
+
+public fun <T> DataFrame<T>.cumSum(vararg columns: String, skipNA: Boolean = defaultCumSumSkipNA): DataFrame<T> =
+    cumSum(skipNA) { columns.toColumnSet() }
+
+public fun <T> DataFrame<T>.cumSum(
+    vararg columns: AnyColumnReference,
+    skipNA: Boolean = defaultCumSumSkipNA,
+): DataFrame<T> = cumSum(skipNA) { columns.toColumnSet() }
+
+public fun <T> DataFrame<T>.cumSum(vararg columns: KProperty<*>, skipNA: Boolean = defaultCumSumSkipNA): DataFrame<T> =
+    cumSum(skipNA) { columns.toColumnSet() }
+
+public fun <T> DataFrame<T>.cumSum(skipNA: Boolean = defaultCumSumSkipNA): DataFrame<T> =
+    cumSum(skipNA) {
+        colsAtAnyDepth { !it.isColumnGroup() }
+    }
+
+// endregion
+
+// region GroupBy
+
+public fun <T, G, C> GroupBy<T, G>.cumSum(
+    skipNA: Boolean = defaultCumSumSkipNA,
+    columns: ColumnsSelector<G, C>,
+): GroupBy<T, G> = updateGroups { cumSum(skipNA, columns) }
+
+public fun <T, G> GroupBy<T, G>.cumSum(vararg columns: String, skipNA: Boolean = defaultCumSumSkipNA): GroupBy<T, G> =
+    cumSum(skipNA) { columns.toColumnSet() }
+
+public fun <T, G> GroupBy<T, G>.cumSum(
+    vararg columns: AnyColumnReference,
+    skipNA: Boolean = defaultCumSumSkipNA,
+): GroupBy<T, G> = cumSum(skipNA) { columns.toColumnSet() }
+
+public fun <T, G> GroupBy<T, G>.cumSum(
+    vararg columns: KProperty<*>,
+    skipNA: Boolean = defaultCumSumSkipNA,
+): GroupBy<T, G> = cumSum(skipNA) { columns.toColumnSet() }
+
+public fun <T, G> GroupBy<T, G>.cumSum(skipNA: Boolean = defaultCumSumSkipNA): GroupBy<T, G> =
+    cumSum(skipNA) {
+        colsAtAnyDepth { !it.isColumnGroup() }
+    }
+
+// endregion
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/describe.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/describe.kt
new file mode 100644
index 000000000..66b51c588
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/describe.kt
@@ -0,0 +1,59 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import org.jetbrains.kotlinx.dataframe.ColumnsSelector
+import org.jetbrains.kotlinx.dataframe.DataColumn
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.annotations.DataSchema
+import org.jetbrains.kotlinx.dataframe.columns.ColumnPath
+import org.jetbrains.kotlinx.dataframe.columns.ColumnReference
+import org.jetbrains.kotlinx.dataframe.columns.toColumnSet
+import org.jetbrains.kotlinx.dataframe.impl.api.describeImpl
+import kotlin.reflect.KProperty
+import kotlin.reflect.KType
+
+// region DataSchema
+@DataSchema
+public interface ColumnDescription {
+    public val name: String
+    public val path: ColumnPath
+    public val type: KType
+    public val count: Int
+    public val unique: Int
+    public val nulls: Int
+    public val top: Any
+    public val freq: Int
+    public val mean: Double
+    public val std: Double
+    public val min: Any
+    public val median: Any
+    public val max: Any
+}
+
+// endregion
+
+// region DataColumn
+
+public fun <T> DataColumn<T>.describe(): DataFrame<ColumnDescription> = describeImpl(listOf(this))
+
+// endregion
+
+// region DataFrame
+
+public fun <T> DataFrame<T>.describe(): DataFrame<ColumnDescription> =
+    describe {
+        colsAtAnyDepth { !it.isColumnGroup() }
+    }
+
+public fun <T> DataFrame<T>.describe(columns: ColumnsSelector<T, *>): DataFrame<ColumnDescription> =
+    describeImpl(getColumnsWithPaths(columns))
+
+public fun <T> DataFrame<T>.describe(vararg columns: String): DataFrame<ColumnDescription> =
+    describe { columns.toColumnSet() }
+
+public fun <T, C : Number?> DataFrame<T>.describe(vararg columns: ColumnReference<C>): DataFrame<ColumnDescription> =
+    describe { columns.toColumnSet() }
+
+public fun <T, C : Number?> DataFrame<T>.describe(vararg columns: KProperty<C>): DataFrame<ColumnDescription> =
+    describe { columns.toColumnSet() }
+
+// endregion
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/digitize.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/digitize.kt
new file mode 100644
index 000000000..da118b323
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/digitize.kt
@@ -0,0 +1,39 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import org.jetbrains.kotlinx.dataframe.DataColumn
+import kotlin.reflect.KClass
+
+// region DataColumn
+
+public fun DataColumn<Double>.digitize(vararg bins: Int, right: Boolean = false): DataColumn<Int> =
+    digitize(bins.toList(), Double::class, right)
+
+public fun <T : Comparable<T>> DataColumn<T>.digitize(vararg bins: T, right: Boolean = false): DataColumn<Int> =
+    digitize(bins.toList(), right)
+
+public fun <T : Comparable<T>> DataColumn<T>.digitize(
+    bins: List<Int>,
+    kclass: KClass<T>,
+    right: Boolean = false,
+): DataColumn<Int> =
+    digitize(
+        bins = bins.toList().map { org.jetbrains.kotlinx.dataframe.impl.convert(it, kclass) },
+        right = right,
+    )
+
+public fun <T : Comparable<T>> DataColumn<T>.digitize(bins: List<T>, right: Boolean = false): DataColumn<Int> {
+    // TODO: use binary search
+    // TODO: support descending order of bins
+    val predicate: (T, T) -> Boolean = if (right) { value, bin -> value <= bin } else { value, bin -> value < bin }
+
+    return map { value ->
+        val index = bins.indexOfFirst { predicate(value, it) }
+        if (index == -1) {
+            bins.size
+        } else {
+            index
+        }
+    }
+}
+
+// endregion
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/distinct.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/distinct.kt
new file mode 100644
index 000000000..a3b5aa625
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/distinct.kt
@@ -0,0 +1,124 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import org.jetbrains.kotlinx.dataframe.AnyColumnReference
+import org.jetbrains.kotlinx.dataframe.ColumnsSelector
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.api.DistinctColumnsSelectionDsl.Grammar
+import org.jetbrains.kotlinx.dataframe.columns.ColumnSet
+import org.jetbrains.kotlinx.dataframe.columns.SingleColumn
+import org.jetbrains.kotlinx.dataframe.columns.toColumnSet
+import org.jetbrains.kotlinx.dataframe.exceptions.DuplicateColumnNamesException
+import org.jetbrains.kotlinx.dataframe.impl.columns.DistinctColumnSet
+import org.jetbrains.kotlinx.dataframe.indices
+import kotlin.reflect.KProperty
+
+// region DataFrame
+
+public fun <T> DataFrame<T>.distinct(): DataFrame<T> = distinctBy { all() }
+
+public fun <T, C> DataFrame<T>.distinct(columns: ColumnsSelector<T, C>): DataFrame<T> = select(columns).distinct()
+
+public fun <T> DataFrame<T>.distinct(vararg columns: KProperty<*>): DataFrame<T> =
+    distinct {
+        val set = columns.toColumnSet()
+        set
+    }
+
+public fun <T> DataFrame<T>.distinct(vararg columns: String): DataFrame<T> = distinct { columns.toColumnSet() }
+
+public fun <T> DataFrame<T>.distinct(vararg columns: AnyColumnReference): DataFrame<T> =
+    distinct { columns.toColumnSet() }
+
+public fun <T> DataFrame<T>.distinctBy(vararg columns: KProperty<*>): DataFrame<T> =
+    distinctBy { columns.toColumnSet() }
+
+public fun <T> DataFrame<T>.distinctBy(vararg columns: String): DataFrame<T> = distinctBy { columns.toColumnSet() }
+
+public fun <T> DataFrame<T>.distinctBy(vararg columns: AnyColumnReference): DataFrame<T> =
+    distinctBy { columns.toColumnSet() }
+
+public fun <T, C> DataFrame<T>.distinctBy(columns: ColumnsSelector<T, C>): DataFrame<T> {
+    val cols = get(columns)
+    val distinctIndices = indices.distinctBy { i -> cols.map { it[i] } }
+    return this[distinctIndices]
+}
+
+// endregion
+
+// region ColumnsSelectionDsl
+
+/**
+ * ## Distinct [Columns Selection DSL][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl]
+ *
+ * See [Grammar] for all functions in this interface.
+ */
+public interface DistinctColumnsSelectionDsl {
+
+    /**
+     * ## Distinct Grammar
+     *
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * [(What is this notation?)][org.jetbrains.kotlinx.dataframe.documentation.DslGrammar]
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  ### Definitions:
+     *  `columnSet: `[`ColumnSet`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]`<*>`
+     *
+     *
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  ### What can be called on a [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]:
+     *
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  [`columnSet`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ColumnSetDef]
+     *
+     *  &nbsp;&nbsp;&nbsp;&nbsp;__`.`__[**`distinct`**][org.jetbrains.kotlinx.dataframe.api.DistinctColumnsSelectionDsl.distinct]**`()`**
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     */
+    public interface Grammar {
+
+        /** __`.`__[**`distinct`**][ColumnsSelectionDsl.distinct] */
+        public interface ColumnSetName
+    }
+
+    /**
+     * ## Distinct
+     * Returns a new [ColumnSet] from [this] [ColumnSet] containing only distinct columns (by path).
+     * This is useful when you've selected the same column multiple times but only want it once.
+     *
+     * NOTE: This doesn't solve [DuplicateColumnNamesException] if you've selected two columns with the same name.
+     * For this, you'll need to [rename][ColumnsSelectionDsl.named] one of the columns.
+     *
+     * ### Check out: [Grammar]
+     *
+     * #### For Example:
+     * `df.`[select][DataFrame.select]` { (`[colsOf][SingleColumn.colsOf]`<`[Int][Int]`>() `[and][ColumnsSelectionDsl.and]` age).`[distinct][ColumnSet.distinct]`() }`
+     *
+     * `df.`[select][DataFrame.select]`  {  `[colsAtAnyDepth][ColumnsSelectionDsl.colsAtAnyDepth]`().`[nameStartsWith][ColumnsSelectionDsl.nameStartsWith]`("order").`[distinct][ColumnSet.distinct]`() }`
+     *
+     * @return A new [ColumnSet] containing only distinct columns (by path).
+     * @see ColumnsSelectionDsl.named
+     * @see ColumnsSelectionDsl.simplify
+     */
+    public fun <C> ColumnSet<C>.distinct(): ColumnSet<C> = DistinctColumnSet(this)
+}
+
+// endregion
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/drop.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/drop.kt
new file mode 100644
index 000000000..747b41eb3
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/drop.kt
@@ -0,0 +1,1097 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import org.jetbrains.kotlinx.dataframe.ColumnFilter
+import org.jetbrains.kotlinx.dataframe.DataColumn
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.DataRow
+import org.jetbrains.kotlinx.dataframe.Predicate
+import org.jetbrains.kotlinx.dataframe.RowFilter
+import org.jetbrains.kotlinx.dataframe.columns.ColumnPath
+import org.jetbrains.kotlinx.dataframe.columns.ColumnSet
+import org.jetbrains.kotlinx.dataframe.columns.ColumnWithPath
+import org.jetbrains.kotlinx.dataframe.columns.SingleColumn
+import org.jetbrains.kotlinx.dataframe.columns.size
+import org.jetbrains.kotlinx.dataframe.impl.columns.transform
+import org.jetbrains.kotlinx.dataframe.impl.columns.transformSingle
+import org.jetbrains.kotlinx.dataframe.index
+import org.jetbrains.kotlinx.dataframe.nrow
+import kotlin.reflect.KProperty
+
+// region DataColumn
+
+public fun <T> DataColumn<T>.drop(predicate: Predicate<T>): DataColumn<T> = filter { !predicate(it) }
+
+public fun <T> DataColumn<T>.drop(n: Int): DataColumn<T> =
+    when {
+        n == 0 -> this
+        n >= size -> get(emptyList())
+        else -> get(n until size)
+    }
+
+public fun <T> DataColumn<T>.dropLast(n: Int = 1): DataColumn<T> = take(size - n)
+
+// endregion
+
+// region DataFrame
+
+/**
+ * Returns a DataFrame containing all rows except first [n] rows.
+ *
+ * @throws IllegalArgumentException if [n] is negative.
+ */
+public fun <T> DataFrame<T>.drop(n: Int): DataFrame<T> {
+    require(n >= 0) { "Requested rows count $n is less than zero." }
+    return getRows(n.coerceAtMost(nrow) until nrow)
+}
+
+/**
+ * Returns a DataFrame containing all rows except last [n] rows.
+ *
+ * @throws IllegalArgumentException if [n] is negative.
+ */
+public fun <T> DataFrame<T>.dropLast(n: Int = 1): DataFrame<T> {
+    require(n >= 0) { "Requested rows count $n is less than zero." }
+    return take((nrow - n).coerceAtLeast(0))
+}
+
+/**
+ * Returns a DataFrame containing all rows except rows that satisfy the given [predicate].
+ */
+public fun <T> DataFrame<T>.drop(predicate: RowFilter<T>): DataFrame<T> = filter { !predicate(it, it) }
+
+/**
+ * Returns a DataFrame containing all rows except first rows that satisfy the given [predicate].
+ */
+public fun <T> DataFrame<T>.dropWhile(predicate: RowFilter<T>): DataFrame<T> =
+    firstOrNull { !predicate(it, it) }?.let { drop(it.index) } ?: this
+
+// endregion
+
+// region ColumnsSelectionDsl
+
+/**
+ * ## Drop [Columns Selection DSL][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl]
+ *
+ * See [Grammar] for all functions in this interface.
+ */
+public interface DropColumnsSelectionDsl {
+
+    /**
+     * ## Drop (Last) (Cols) (While) Grammar
+     *
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * [(What is this notation?)][org.jetbrains.kotlinx.dataframe.documentation.DslGrammar]
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  ### Definitions:
+     *  `columnSet: `[`ColumnSet`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]`<*>`
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  `columnGroup: `[`SingleColumn`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]`<`[`DataRow`][org.jetbrains.kotlinx.dataframe.DataRow]`<*>> | `[`String`][String]`  |  `[`KProperty`][kotlin.reflect.KProperty]`<* | `[`DataRow`][org.jetbrains.kotlinx.dataframe.DataRow]`<*>> | `[`ColumnPath`][org.jetbrains.kotlinx.dataframe.columns.ColumnPath]
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  `condition: `[`ColumnFilter`][org.jetbrains.kotlinx.dataframe.ColumnFilter]
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  `number: `[`Int`][Int]
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  ### What can be called directly in the [Columns Selection DSL][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl]:
+     *
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  [**`drop`**][ColumnsSelectionDsl.drop]`(`[**`Last`**][ColumnsSelectionDsl.dropLast]`)`**`(`**[`number`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.NumberDef]**`)`**
+     *
+     *  `| `[**`drop`**][ColumnsSelectionDsl.dropWhile]`(`[**`Last`**][ColumnsSelectionDsl.dropLastWhile]`)`[**`While`**][ColumnsSelectionDsl.dropWhile]**`  {  `**[`condition`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ConditionDef]**` }`**
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  ### What can be called on a [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]:
+     *
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  [`columnSet`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ColumnSetDef]
+     *
+     *  &nbsp;&nbsp;&nbsp;&nbsp;__`.`__[**`drop`**][ColumnsSelectionDsl.drop]`(`[**`Last`**][ColumnSet.dropLast]`)`**`(`**[`number`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.NumberDef]**`)`**
+     *
+     *  &nbsp;&nbsp;&nbsp;&nbsp;`| `__`.`__[**`drop`**][ColumnsSelectionDsl.dropWhile]`(`[**`Last`**][ColumnsSelectionDsl.dropLastWhile]`)`[**`While`**][ColumnsSelectionDsl.dropWhile]**`  {  `**[`condition`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ConditionDef]**` }`**
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  ### What can be called on a [Column Group (reference)][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ColumnGroupDef]:
+     *
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  [`columnGroup`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ColumnGroupDef]
+     *
+     *  &nbsp;&nbsp;&nbsp;&nbsp;__`.`__[**`drop`**][ColumnsSelectionDsl.dropCols]`(`[**`Last`**][ColumnsSelectionDsl.dropLastCols]`)`[**`Cols`**][ColumnsSelectionDsl.dropCols]**`(`**[`number`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.NumberDef]**`)`**
+     *
+     *  &nbsp;&nbsp;&nbsp;&nbsp;`| `__`.`__[**`drop`**][ColumnsSelectionDsl.dropColsWhile]`(`[**`Last`**][ColumnsSelectionDsl.dropLastColsWhile]`)`[**`ColsWhile`**][ColumnsSelectionDsl.dropColsWhile]**`  {  `**[`condition`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ConditionDef]**` }`**
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     */
+    public interface Grammar {
+
+        /** [**`drop`**][ColumnsSelectionDsl.drop]`(`[**`Last`**][ColumnsSelectionDsl.dropLast]`)` */
+        public interface PlainDslName
+
+        /** __`.`__[**`drop`**][ColumnsSelectionDsl.drop]`(`[**`Last`**][ColumnSet.dropLast]`)` */
+        public interface ColumnSetName
+
+        /** __`.`__[**`drop`**][ColumnsSelectionDsl.dropCols]`(`[**`Last`**][ColumnsSelectionDsl.dropLastCols]`)`[**`Cols`**][ColumnsSelectionDsl.dropCols] */
+        public interface ColumnGroupName
+
+        /** [**`drop`**][ColumnsSelectionDsl.dropWhile]`(`[**`Last`**][ColumnsSelectionDsl.dropLastWhile]`)`[**`While`**][ColumnsSelectionDsl.dropWhile] */
+        public interface PlainDslWhileName
+
+        /** __`.`__[**`drop`**][ColumnsSelectionDsl.dropWhile]`(`[**`Last`**][ColumnsSelectionDsl.dropLastWhile]`)`[**`While`**][ColumnsSelectionDsl.dropWhile] */
+        public interface ColumnSetWhileName
+
+        /** __`.`__[**`drop`**][ColumnsSelectionDsl.dropColsWhile]`(`[**`Last`**][ColumnsSelectionDsl.dropLastColsWhile]`)`[**`ColsWhile`**][ColumnsSelectionDsl.dropColsWhile] */
+        public interface ColumnGroupWhileName
+    }
+
+    // region drop
+
+    /**
+     * ## Drop (Cols)
+     * This drops the first [n] columns from [this] collecting
+     * the result into a [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet].
+     *
+     * This function operates solely on columns at the top-level.
+     *
+     * Any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi] can be used as receiver for these functions.
+     *
+     * NOTE: To avoid ambiguity, `drop` is called `dropCols` when called on
+     * a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * ### Check out: [Grammar]
+     *
+     * #### Examples:
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { `[cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]` { "my" `[in][String.contains]` it.`[name][org.jetbrains.kotlinx.dataframe.DataColumn.name]` }.`[drop][ColumnSet.drop]`(5) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { `[drop][ColumnsSelectionDsl.drop]`(1) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[dropCols][SingleColumn.dropCols]`(2) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "myColumnGroup".`[dropCols][String.dropCols]`(3) }`
+     *
+     * #### Examples for this overload:
+     *
+     *
+     *
+     * @param [n] The number of columns to drop.
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing the first [n] columns.
+     */
+    private interface CommonDropFirstDocs
+
+    /**
+     * ## Drop (Cols)
+     * This drops the first [n] columns from [this] collecting
+     * the result into a [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet].
+     *
+     * This function operates solely on columns at the top-level.
+     *
+     * Any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi] can be used as receiver for these functions.
+     *
+     * NOTE: To avoid ambiguity, `drop` is called `dropCols` when called on
+     * a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * ### Check out: [Grammar]
+     *
+     * #### Examples:
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { `[cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]` { "my" `[in][String.contains]` it.`[name][org.jetbrains.kotlinx.dataframe.DataColumn.name]` }.`[drop][ColumnSet.drop]`(5) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { `[drop][ColumnsSelectionDsl.drop]`(1) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[dropCols][SingleColumn.dropCols]`(2) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "myColumnGroup".`[dropCols][String.dropCols]`(3) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][DataFrame.select]`  {  `[colsOf][SingleColumn.colsOf]`<`[String][String]`>().`[drop][ColumnSet.drop]`(2) }`
+     *
+     * `df.`[select][DataFrame.select]`  {  `[cols][ColumnsSelectionDsl.cols]` { .. }.`[drop][ColumnSet.drop]`(2) }`
+     *
+     * @param [n] The number of columns to drop.
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing the first [n] columns.
+     */
+    public fun <C> ColumnSet<C>.drop(n: Int): ColumnSet<C> = transform { it.drop(n) }
+
+    /**
+     * ## Drop (Cols)
+     * This drops the first [n] columns from [this] collecting
+     * the result into a [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet].
+     *
+     * This function operates solely on columns at the top-level.
+     *
+     * Any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi] can be used as receiver for these functions.
+     *
+     * NOTE: To avoid ambiguity, `drop` is called `dropCols` when called on
+     * a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * ### Check out: [Grammar]
+     *
+     * #### Examples:
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { `[cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]` { "my" `[in][String.contains]` it.`[name][org.jetbrains.kotlinx.dataframe.DataColumn.name]` }.`[drop][ColumnSet.drop]`(5) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { `[drop][ColumnsSelectionDsl.drop]`(1) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[dropCols][SingleColumn.dropCols]`(2) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "myColumnGroup".`[dropCols][String.dropCols]`(3) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][DataFrame.select]`  {  `[drop][ColumnsSelectionDsl.drop]`(5) }`
+     *
+     * @param [n] The number of columns to drop.
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing the first [n] columns.
+     */
+    public fun ColumnsSelectionDsl<*>.drop(n: Int): ColumnSet<*> = asSingleColumn().dropCols(n)
+
+    /**
+     * ## Drop (Cols)
+     * This drops the first [n] columns from [this] collecting
+     * the result into a [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet].
+     *
+     * This function operates solely on columns at the top-level.
+     *
+     * Any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi] can be used as receiver for these functions.
+     *
+     * NOTE: To avoid ambiguity, `drop` is called `dropCols` when called on
+     * a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * ### Check out: [Grammar]
+     *
+     * #### Examples:
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { `[cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]` { "my" `[in][String.contains]` it.`[name][org.jetbrains.kotlinx.dataframe.DataColumn.name]` }.`[drop][ColumnSet.drop]`(5) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { `[drop][ColumnsSelectionDsl.drop]`(1) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[dropCols][SingleColumn.dropCols]`(2) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "myColumnGroup".`[dropCols][String.dropCols]`(3) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][DataFrame.select]` { myColumnGroup.`[dropCols][SingleColumn.dropCols]`(1) }`
+     *
+     * @param [n] The number of columns to drop.
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing the first [n] columns.
+     */
+    public fun SingleColumn<DataRow<*>>.dropCols(n: Int): ColumnSet<*> =
+        this.ensureIsColumnGroup().transformSingle { it.cols().drop(n) }
+
+    /**
+     * ## Drop (Cols)
+     * This drops the first [n] columns from [this] collecting
+     * the result into a [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet].
+     *
+     * This function operates solely on columns at the top-level.
+     *
+     * Any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi] can be used as receiver for these functions.
+     *
+     * NOTE: To avoid ambiguity, `drop` is called `dropCols` when called on
+     * a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * ### Check out: [Grammar]
+     *
+     * #### Examples:
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { `[cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]` { "my" `[in][String.contains]` it.`[name][org.jetbrains.kotlinx.dataframe.DataColumn.name]` }.`[drop][ColumnSet.drop]`(5) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { `[drop][ColumnsSelectionDsl.drop]`(1) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[dropCols][SingleColumn.dropCols]`(2) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "myColumnGroup".`[dropCols][String.dropCols]`(3) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][DataFrame.select]` { "myColumnGroup".`[dropCols][String.dropCols]`(1) }`
+     *
+     * @param [n] The number of columns to drop.
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing the first [n] columns.
+     */
+    public fun String.dropCols(n: Int): ColumnSet<*> = columnGroup(this).dropCols(n)
+
+    /**
+     * ## Drop (Cols)
+     * This drops the first [n] columns from [this] collecting
+     * the result into a [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet].
+     *
+     * This function operates solely on columns at the top-level.
+     *
+     * Any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi] can be used as receiver for these functions.
+     *
+     * NOTE: To avoid ambiguity, `drop` is called `dropCols` when called on
+     * a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * ### Check out: [Grammar]
+     *
+     * #### Examples:
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { `[cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]` { "my" `[in][String.contains]` it.`[name][org.jetbrains.kotlinx.dataframe.DataColumn.name]` }.`[drop][ColumnSet.drop]`(5) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { `[drop][ColumnsSelectionDsl.drop]`(1) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[dropCols][SingleColumn.dropCols]`(2) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "myColumnGroup".`[dropCols][String.dropCols]`(3) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][DataFrame.select]` { DataSchemaType::myColumnGroup.`[dropCols][KProperty.dropCols]`(1) }`
+     *
+     * @param [n] The number of columns to drop.
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing the first [n] columns.
+     */
+    public fun KProperty<*>.dropCols(n: Int): ColumnSet<*> = columnGroup(this).dropCols(n)
+
+    /**
+     * ## Drop (Cols)
+     * This drops the first [n] columns from [this] collecting
+     * the result into a [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet].
+     *
+     * This function operates solely on columns at the top-level.
+     *
+     * Any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi] can be used as receiver for these functions.
+     *
+     * NOTE: To avoid ambiguity, `drop` is called `dropCols` when called on
+     * a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * ### Check out: [Grammar]
+     *
+     * #### Examples:
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { `[cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]` { "my" `[in][String.contains]` it.`[name][org.jetbrains.kotlinx.dataframe.DataColumn.name]` }.`[drop][ColumnSet.drop]`(5) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { `[drop][ColumnsSelectionDsl.drop]`(1) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[dropCols][SingleColumn.dropCols]`(2) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "myColumnGroup".`[dropCols][String.dropCols]`(3) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][DataFrame.select]` { "pathTo"["myColumnGroup"].`[dropCols][ColumnPath.dropCols]`(1) }`
+     *
+     * @param [n] The number of columns to drop.
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing the first [n] columns.
+     */
+    public fun ColumnPath.dropCols(n: Int): ColumnSet<*> = columnGroup(this).dropCols(n)
+
+    // endregion
+
+    // region dropLast
+
+    /**
+     * ## Drop Last (Cols)
+     * This drops the last [n] columns from [this] collecting
+     * the result into a [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet].
+     *
+     * This function operates solely on columns at the top-level.
+     *
+     * Any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi] can be used as receiver for these functions.
+     *
+     * NOTE: To avoid ambiguity, `dropLast` is called `dropLastCols` when called on
+     * a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * ### Check out: [Grammar]
+     *
+     * #### Examples:
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { `[cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]` { "my" `[in][String.contains]` it.`[name][org.jetbrains.kotlinx.dataframe.DataColumn.name]` }.`[dropLast][ColumnSet.dropLast]`(5) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { `[dropLast][ColumnsSelectionDsl.dropLast]`(1) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[dropLastCols][SingleColumn.dropLastCols]`(2) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "myColumnGroup".`[dropLastCols][String.dropLastCols]`(3) }`
+     *
+     * #### Examples for this overload:
+     *
+     *
+     *
+     * @param [n] The number of columns to drop.
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing the last [n] columns.
+     */
+    private interface CommonDropLastDocs
+
+    /**
+     * ## Drop Last (Cols)
+     * This drops the last [n] columns from [this] collecting
+     * the result into a [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet].
+     *
+     * This function operates solely on columns at the top-level.
+     *
+     * Any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi] can be used as receiver for these functions.
+     *
+     * NOTE: To avoid ambiguity, `dropLast` is called `dropLastCols` when called on
+     * a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * ### Check out: [Grammar]
+     *
+     * #### Examples:
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { `[cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]` { "my" `[in][String.contains]` it.`[name][org.jetbrains.kotlinx.dataframe.DataColumn.name]` }.`[dropLast][ColumnSet.dropLast]`(5) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { `[dropLast][ColumnsSelectionDsl.dropLast]`(1) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[dropLastCols][SingleColumn.dropLastCols]`(2) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "myColumnGroup".`[dropLastCols][String.dropLastCols]`(3) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][DataFrame.select]`  {  `[colsOf][SingleColumn.colsOf]`<`[String][String]`>().`[dropLast][ColumnSet.dropLast]`(2) }`
+     *
+     * `df.`[select][DataFrame.select]`  {  `[cols][ColumnsSelectionDsl.cols]` { .. }.`[dropLast][ColumnSet.dropLast]`() }`
+     *
+     * @param [n] The number of columns to drop.
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing the last [n] columns.
+     */
+    public fun <C> ColumnSet<C>.dropLast(n: Int = 1): ColumnSet<C> = transform { it.dropLast(n) }
+
+    /**
+     * ## Drop Last (Cols)
+     * This drops the last [n] columns from [this] collecting
+     * the result into a [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet].
+     *
+     * This function operates solely on columns at the top-level.
+     *
+     * Any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi] can be used as receiver for these functions.
+     *
+     * NOTE: To avoid ambiguity, `dropLast` is called `dropLastCols` when called on
+     * a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * ### Check out: [Grammar]
+     *
+     * #### Examples:
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { `[cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]` { "my" `[in][String.contains]` it.`[name][org.jetbrains.kotlinx.dataframe.DataColumn.name]` }.`[dropLast][ColumnSet.dropLast]`(5) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { `[dropLast][ColumnsSelectionDsl.dropLast]`(1) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[dropLastCols][SingleColumn.dropLastCols]`(2) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "myColumnGroup".`[dropLastCols][String.dropLastCols]`(3) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][DataFrame.select]`  {  `[dropLast][ColumnsSelectionDsl.dropLast]`(5) }`
+     *
+     * @param [n] The number of columns to drop.
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing the last [n] columns.
+     */
+    public fun ColumnsSelectionDsl<*>.dropLast(n: Int = 1): ColumnSet<*> = this.asSingleColumn().dropLastCols(n)
+
+    /**
+     * ## Drop Last (Cols)
+     * This drops the last [n] columns from [this] collecting
+     * the result into a [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet].
+     *
+     * This function operates solely on columns at the top-level.
+     *
+     * Any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi] can be used as receiver for these functions.
+     *
+     * NOTE: To avoid ambiguity, `dropLast` is called `dropLastCols` when called on
+     * a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * ### Check out: [Grammar]
+     *
+     * #### Examples:
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { `[cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]` { "my" `[in][String.contains]` it.`[name][org.jetbrains.kotlinx.dataframe.DataColumn.name]` }.`[dropLast][ColumnSet.dropLast]`(5) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { `[dropLast][ColumnsSelectionDsl.dropLast]`(1) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[dropLastCols][SingleColumn.dropLastCols]`(2) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "myColumnGroup".`[dropLastCols][String.dropLastCols]`(3) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][DataFrame.select]` { myColumnGroup.`[dropLastCols][SingleColumn.dropLastCols]`() }`
+     *
+     * @param [n] The number of columns to drop.
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing the last [n] columns.
+     */
+    public fun SingleColumn<DataRow<*>>.dropLastCols(n: Int): ColumnSet<*> =
+        this.ensureIsColumnGroup().transformSingle { it.cols().dropLast(n) }
+
+    /**
+     * ## Drop Last (Cols)
+     * This drops the last [n] columns from [this] collecting
+     * the result into a [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet].
+     *
+     * This function operates solely on columns at the top-level.
+     *
+     * Any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi] can be used as receiver for these functions.
+     *
+     * NOTE: To avoid ambiguity, `dropLast` is called `dropLastCols` when called on
+     * a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * ### Check out: [Grammar]
+     *
+     * #### Examples:
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { `[cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]` { "my" `[in][String.contains]` it.`[name][org.jetbrains.kotlinx.dataframe.DataColumn.name]` }.`[dropLast][ColumnSet.dropLast]`(5) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { `[dropLast][ColumnsSelectionDsl.dropLast]`(1) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[dropLastCols][SingleColumn.dropLastCols]`(2) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "myColumnGroup".`[dropLastCols][String.dropLastCols]`(3) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][DataFrame.select]` { "myColumnGroup".`[dropLastCols][String.dropLastCols]`(1) }`
+     *
+     * @param [n] The number of columns to drop.
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing the last [n] columns.
+     */
+    public fun String.dropLastCols(n: Int): ColumnSet<*> = columnGroup(this).dropLastCols(n)
+
+    /**
+     * ## Drop Last (Cols)
+     * This drops the last [n] columns from [this] collecting
+     * the result into a [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet].
+     *
+     * This function operates solely on columns at the top-level.
+     *
+     * Any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi] can be used as receiver for these functions.
+     *
+     * NOTE: To avoid ambiguity, `dropLast` is called `dropLastCols` when called on
+     * a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * ### Check out: [Grammar]
+     *
+     * #### Examples:
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { `[cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]` { "my" `[in][String.contains]` it.`[name][org.jetbrains.kotlinx.dataframe.DataColumn.name]` }.`[dropLast][ColumnSet.dropLast]`(5) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { `[dropLast][ColumnsSelectionDsl.dropLast]`(1) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[dropLastCols][SingleColumn.dropLastCols]`(2) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "myColumnGroup".`[dropLastCols][String.dropLastCols]`(3) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][DataFrame.select]` { DataSchemaType::myColumnGroup.`[dropLastCols][KProperty.dropLastCols]`(1) }`
+     *
+     * @param [n] The number of columns to drop.
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing the last [n] columns.
+     */
+    public fun KProperty<*>.dropLastCols(n: Int): ColumnSet<*> = columnGroup(this).dropLastCols(n)
+
+    /**
+     * ## Drop Last (Cols)
+     * This drops the last [n] columns from [this] collecting
+     * the result into a [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet].
+     *
+     * This function operates solely on columns at the top-level.
+     *
+     * Any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi] can be used as receiver for these functions.
+     *
+     * NOTE: To avoid ambiguity, `dropLast` is called `dropLastCols` when called on
+     * a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * ### Check out: [Grammar]
+     *
+     * #### Examples:
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { `[cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]` { "my" `[in][String.contains]` it.`[name][org.jetbrains.kotlinx.dataframe.DataColumn.name]` }.`[dropLast][ColumnSet.dropLast]`(5) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { `[dropLast][ColumnsSelectionDsl.dropLast]`(1) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[dropLastCols][SingleColumn.dropLastCols]`(2) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "myColumnGroup".`[dropLastCols][String.dropLastCols]`(3) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][DataFrame.select]` { "pathTo"["myColumnGroup"].`[dropLastCols][ColumnPath.dropLastCols]`(1) }`
+     *
+     * @param [n] The number of columns to drop.
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing the last [n] columns.
+     */
+    public fun ColumnPath.dropLastCols(n: Int): ColumnSet<*> = columnGroup(this).dropLastCols(n)
+
+    // endregion
+
+    // region dropWhile
+
+    /**
+     * ## Drop (Cols) While
+     * This function drops the first columns from [this] adhering to the
+     * given [predicate] collecting the result into a [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet].
+     *
+     * This function operates solely on columns at the top-level.
+     *
+     * Any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi] can be used as receiver for these functions.
+     *
+     * NOTE: To avoid ambiguity, `dropWhile` is called
+     * `dropColsWhile` when called on a [String] or [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath] resembling
+     * a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * ### Check out: [Usage]
+     *
+     * #### Examples:
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { `[`cols`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]` { "my" `[`in`][String.contains]` it.`[`name`][org.jetbrains.kotlinx.dataframe.DataColumn.name]` }.`[`dropWhile`][ColumnSet.dropWhile]` { "my" `[`in`][String.contains]` it.`[`name`][org.jetbrains.kotlinx.dataframe.DataColumn.name]` } }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[`dropWhile`][SingleColumn.dropColsWhile]` { it.`[`any`][org.jetbrains.kotlinx.dataframe.DataColumn.any]` { it == "Alice" } } }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "myColumnGroup".`[`dropColsWhile`][String.dropColsWhile]` { it.`[`kind`][org.jetbrains.kotlinx.dataframe.DataColumn.kind]`() == `[`ColumnKind.Value`][org.jetbrains.kotlinx.dataframe.columns.ColumnKind.Value]` } }`
+     *
+     * #### Examples for this overload:
+     *
+     *
+     *
+     * @param [predicate] The [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter] to control which columns to drop.
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing the first columns adhering to the [predicate].
+     */
+    private interface CommonDropWhileDocs
+
+    /**
+     * ## Drop (Cols) While
+     * This function drops the first columns from [this] adhering to the
+     * given [predicate] collecting the result into a [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet].
+     *
+     * This function operates solely on columns at the top-level.
+     *
+     * Any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi] can be used as receiver for these functions.
+     *
+     * NOTE: To avoid ambiguity, `dropWhile` is called
+     * `dropColsWhile` when called on a [String] or [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath] resembling
+     * a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * ### Check out: [Usage]
+     *
+     * #### Examples:
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { `[`cols`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]` { "my" `[`in`][String.contains]` it.`[`name`][org.jetbrains.kotlinx.dataframe.DataColumn.name]` }.`[`dropWhile`][ColumnSet.dropWhile]` { "my" `[`in`][String.contains]` it.`[`name`][org.jetbrains.kotlinx.dataframe.DataColumn.name]` } }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[`dropWhile`][SingleColumn.dropColsWhile]` { it.`[`any`][org.jetbrains.kotlinx.dataframe.DataColumn.any]` { it == "Alice" } } }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "myColumnGroup".`[`dropColsWhile`][String.dropColsWhile]` { it.`[`kind`][org.jetbrains.kotlinx.dataframe.DataColumn.kind]`() == `[`ColumnKind.Value`][org.jetbrains.kotlinx.dataframe.columns.ColumnKind.Value]` } }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][DataFrame.select]`  {  `[colsOf][SingleColumn.colsOf]`<`[String][String]`>().`[dropWhile][ColumnSet.dropWhile]` { it.`[any][ColumnWithPath.any]` { it == "Alice" } } }`
+     *
+     * `df.`[select][DataFrame.select]`  {  `[cols][ColumnsSelectionDsl.cols]` { .. }.`[dropWhile][ColumnSet.dropWhile]` { it.`[name][ColumnWithPath.name]`.`[startsWith][String.startsWith]`("my") } }`
+     *
+     * @param [predicate] The [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter] to control which columns to drop.
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing the first columns adhering to the [predicate].
+     */
+    public fun <C> ColumnSet<C>.dropWhile(predicate: ColumnFilter<C>): ColumnSet<C> =
+        transform { it.dropWhile(predicate) }
+
+    /**
+     * ## Drop (Cols) While
+     * This function drops the first columns from [this] adhering to the
+     * given [predicate] collecting the result into a [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet].
+     *
+     * This function operates solely on columns at the top-level.
+     *
+     * Any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi] can be used as receiver for these functions.
+     *
+     * NOTE: To avoid ambiguity, `dropWhile` is called
+     * `dropColsWhile` when called on a [String] or [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath] resembling
+     * a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * ### Check out: [Usage]
+     *
+     * #### Examples:
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { `[`cols`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]` { "my" `[`in`][String.contains]` it.`[`name`][org.jetbrains.kotlinx.dataframe.DataColumn.name]` }.`[`dropWhile`][ColumnSet.dropWhile]` { "my" `[`in`][String.contains]` it.`[`name`][org.jetbrains.kotlinx.dataframe.DataColumn.name]` } }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[`dropWhile`][SingleColumn.dropColsWhile]` { it.`[`any`][org.jetbrains.kotlinx.dataframe.DataColumn.any]` { it == "Alice" } } }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "myColumnGroup".`[`dropColsWhile`][String.dropColsWhile]` { it.`[`kind`][org.jetbrains.kotlinx.dataframe.DataColumn.kind]`() == `[`ColumnKind.Value`][org.jetbrains.kotlinx.dataframe.columns.ColumnKind.Value]` } }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][DataFrame.select]`  {  `[dropWhile][ColumnsSelectionDsl.dropWhile]` { it.`[any][ColumnWithPath.any]` { it == "Alice" } } }`
+     *
+     * @param [predicate] The [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter] to control which columns to drop.
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing the first columns adhering to the [predicate].
+     */
+    public fun ColumnsSelectionDsl<*>.dropWhile(predicate: ColumnFilter<*>): ColumnSet<*> =
+        this.asSingleColumn().dropColsWhile(predicate)
+
+    /**
+     * ## Drop (Cols) While
+     * This function drops the first columns from [this] adhering to the
+     * given [predicate] collecting the result into a [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet].
+     *
+     * This function operates solely on columns at the top-level.
+     *
+     * Any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi] can be used as receiver for these functions.
+     *
+     * NOTE: To avoid ambiguity, `dropWhile` is called
+     * `dropColsWhile` when called on a [String] or [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath] resembling
+     * a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * ### Check out: [Usage]
+     *
+     * #### Examples:
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { `[`cols`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]` { "my" `[`in`][String.contains]` it.`[`name`][org.jetbrains.kotlinx.dataframe.DataColumn.name]` }.`[`dropWhile`][ColumnSet.dropWhile]` { "my" `[`in`][String.contains]` it.`[`name`][org.jetbrains.kotlinx.dataframe.DataColumn.name]` } }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[`dropWhile`][SingleColumn.dropColsWhile]` { it.`[`any`][org.jetbrains.kotlinx.dataframe.DataColumn.any]` { it == "Alice" } } }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "myColumnGroup".`[`dropColsWhile`][String.dropColsWhile]` { it.`[`kind`][org.jetbrains.kotlinx.dataframe.DataColumn.kind]`() == `[`ColumnKind.Value`][org.jetbrains.kotlinx.dataframe.columns.ColumnKind.Value]` } }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][DataFrame.select]` { myColumnGroup.`[dropColsWhile][SingleColumn.dropColsWhile]` { it.`[name][ColumnWithPath.name]`.`[startsWith][String.startsWith]`("my") } }`
+     *
+     * @param [predicate] The [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter] to control which columns to drop.
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing the first columns adhering to the [predicate].
+     */
+    public fun SingleColumn<DataRow<*>>.dropColsWhile(predicate: ColumnFilter<*>): ColumnSet<*> =
+        this.ensureIsColumnGroup().transformSingle { it.cols().dropWhile(predicate) }
+
+    /**
+     * ## Drop (Cols) While
+     * This function drops the first columns from [this] adhering to the
+     * given [predicate] collecting the result into a [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet].
+     *
+     * This function operates solely on columns at the top-level.
+     *
+     * Any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi] can be used as receiver for these functions.
+     *
+     * NOTE: To avoid ambiguity, `dropWhile` is called
+     * `dropColsWhile` when called on a [String] or [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath] resembling
+     * a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * ### Check out: [Usage]
+     *
+     * #### Examples:
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { `[`cols`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]` { "my" `[`in`][String.contains]` it.`[`name`][org.jetbrains.kotlinx.dataframe.DataColumn.name]` }.`[`dropWhile`][ColumnSet.dropWhile]` { "my" `[`in`][String.contains]` it.`[`name`][org.jetbrains.kotlinx.dataframe.DataColumn.name]` } }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[`dropWhile`][SingleColumn.dropColsWhile]` { it.`[`any`][org.jetbrains.kotlinx.dataframe.DataColumn.any]` { it == "Alice" } } }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "myColumnGroup".`[`dropColsWhile`][String.dropColsWhile]` { it.`[`kind`][org.jetbrains.kotlinx.dataframe.DataColumn.kind]`() == `[`ColumnKind.Value`][org.jetbrains.kotlinx.dataframe.columns.ColumnKind.Value]` } }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][DataFrame.select]` { "myColumnGroup".`[dropColsWhile][String.dropColsWhile]` { it.`[name][ColumnWithPath.name]`.`[startsWith][String.startsWith]`("my") } }`
+     *
+     * @param [predicate] The [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter] to control which columns to drop.
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing the first columns adhering to the [predicate].
+     */
+    public fun String.dropColsWhile(predicate: ColumnFilter<*>): ColumnSet<*> =
+        columnGroup(this).dropColsWhile(predicate)
+
+    /**
+     * ## Drop (Cols) While
+     * This function drops the first columns from [this] adhering to the
+     * given [predicate] collecting the result into a [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet].
+     *
+     * This function operates solely on columns at the top-level.
+     *
+     * Any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi] can be used as receiver for these functions.
+     *
+     * NOTE: To avoid ambiguity, `dropWhile` is called
+     * `dropColsWhile` when called on a [String] or [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath] resembling
+     * a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * ### Check out: [Usage]
+     *
+     * #### Examples:
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { `[`cols`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]` { "my" `[`in`][String.contains]` it.`[`name`][org.jetbrains.kotlinx.dataframe.DataColumn.name]` }.`[`dropWhile`][ColumnSet.dropWhile]` { "my" `[`in`][String.contains]` it.`[`name`][org.jetbrains.kotlinx.dataframe.DataColumn.name]` } }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[`dropWhile`][SingleColumn.dropColsWhile]` { it.`[`any`][org.jetbrains.kotlinx.dataframe.DataColumn.any]` { it == "Alice" } } }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "myColumnGroup".`[`dropColsWhile`][String.dropColsWhile]` { it.`[`kind`][org.jetbrains.kotlinx.dataframe.DataColumn.kind]`() == `[`ColumnKind.Value`][org.jetbrains.kotlinx.dataframe.columns.ColumnKind.Value]` } }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][DataFrame.select]` { DataSchemaType::myColumnGroup.`[dropColsWhile][KProperty.dropColsWhile]` { it.`[any][ColumnWithPath.any]` { it == "Alice" } } }`
+     *
+     * @param [predicate] The [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter] to control which columns to drop.
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing the first columns adhering to the [predicate].
+     */
+    public fun KProperty<*>.dropColsWhile(predicate: ColumnFilter<*>): ColumnSet<*> =
+        columnGroup(this).dropColsWhile(predicate)
+
+    /**
+     * ## Drop (Cols) While
+     * This function drops the first columns from [this] adhering to the
+     * given [predicate] collecting the result into a [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet].
+     *
+     * This function operates solely on columns at the top-level.
+     *
+     * Any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi] can be used as receiver for these functions.
+     *
+     * NOTE: To avoid ambiguity, `dropWhile` is called
+     * `dropColsWhile` when called on a [String] or [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath] resembling
+     * a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * ### Check out: [Usage]
+     *
+     * #### Examples:
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { `[`cols`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]` { "my" `[`in`][String.contains]` it.`[`name`][org.jetbrains.kotlinx.dataframe.DataColumn.name]` }.`[`dropWhile`][ColumnSet.dropWhile]` { "my" `[`in`][String.contains]` it.`[`name`][org.jetbrains.kotlinx.dataframe.DataColumn.name]` } }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[`dropWhile`][SingleColumn.dropColsWhile]` { it.`[`any`][org.jetbrains.kotlinx.dataframe.DataColumn.any]` { it == "Alice" } } }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "myColumnGroup".`[`dropColsWhile`][String.dropColsWhile]` { it.`[`kind`][org.jetbrains.kotlinx.dataframe.DataColumn.kind]`() == `[`ColumnKind.Value`][org.jetbrains.kotlinx.dataframe.columns.ColumnKind.Value]` } }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][DataFrame.select]` { "pathTo"["myColumnGroup"].`[dropColsWhile][ColumnPath.dropColsWhile]` { it.`[name][ColumnWithPath.name]`.`[startsWith][String.startsWith]`("my") } }`
+     *
+     * @param [predicate] The [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter] to control which columns to drop.
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing the first columns adhering to the [predicate].
+     */
+    public fun ColumnPath.dropColsWhile(predicate: ColumnFilter<*>): ColumnSet<*> =
+        columnGroup(this).dropColsWhile(predicate)
+
+    // endregion
+
+    // region dropLastWhile
+
+    /**
+     * ## Drop Last (Cols) While
+     * This function drops the last columns from [this] adhering to the
+     * given [predicate] collecting the result into a [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet].
+     *
+     * This function operates solely on columns at the top-level.
+     *
+     * Any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi] can be used as receiver for these functions.
+     *
+     * NOTE: To avoid ambiguity, `dropLastWhile` is called
+     * `dropLastColsWhile` when called on a [String] or [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath] resembling
+     * a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * ### Check out: [Usage]
+     *
+     * #### Examples:
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { `[`cols`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]` { "my" `[`in`][String.contains]` it.`[`name`][org.jetbrains.kotlinx.dataframe.DataColumn.name]` }.`[`dropLastWhile`][ColumnSet.dropLastWhile]` { "my" `[`in`][String.contains]` it.`[`name`][org.jetbrains.kotlinx.dataframe.DataColumn.name]` } }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[`dropLastWhile`][SingleColumn.dropLastColsWhile]` { it.`[`any`][org.jetbrains.kotlinx.dataframe.DataColumn.any]` { it == "Alice" } } }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "myColumnGroup".`[`dropLastColsWhile`][String.dropLastColsWhile]` { it.`[`kind`][org.jetbrains.kotlinx.dataframe.DataColumn.kind]`() == `[`ColumnKind.Value`][org.jetbrains.kotlinx.dataframe.columns.ColumnKind.Value]` } }`
+     *
+     * #### Examples for this overload:
+     *
+     *
+     *
+     * @param [predicate] The [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter] to control which columns to drop.
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing the last columns adhering to the [predicate].
+     */
+    private interface CommonDropLastWhileDocs
+
+    /**
+     * ## Drop Last (Cols) While
+     * This function drops the last columns from [this] adhering to the
+     * given [predicate] collecting the result into a [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet].
+     *
+     * This function operates solely on columns at the top-level.
+     *
+     * Any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi] can be used as receiver for these functions.
+     *
+     * NOTE: To avoid ambiguity, `dropLastWhile` is called
+     * `dropLastColsWhile` when called on a [String] or [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath] resembling
+     * a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * ### Check out: [Usage]
+     *
+     * #### Examples:
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { `[`cols`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]` { "my" `[`in`][String.contains]` it.`[`name`][org.jetbrains.kotlinx.dataframe.DataColumn.name]` }.`[`dropLastWhile`][ColumnSet.dropLastWhile]` { "my" `[`in`][String.contains]` it.`[`name`][org.jetbrains.kotlinx.dataframe.DataColumn.name]` } }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[`dropLastWhile`][SingleColumn.dropLastColsWhile]` { it.`[`any`][org.jetbrains.kotlinx.dataframe.DataColumn.any]` { it == "Alice" } } }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "myColumnGroup".`[`dropLastColsWhile`][String.dropLastColsWhile]` { it.`[`kind`][org.jetbrains.kotlinx.dataframe.DataColumn.kind]`() == `[`ColumnKind.Value`][org.jetbrains.kotlinx.dataframe.columns.ColumnKind.Value]` } }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][DataFrame.select]`  {  `[colsOf][SingleColumn.colsOf]`<`[String][String]`>().`[dropLastWhile][ColumnSet.dropLastWhile]` { it.`[any][ColumnWithPath.any]` { it == "Alice" } } }`
+     *
+     * `df.`[select][DataFrame.select]`  {  `[cols][ColumnsSelectionDsl.cols]` { .. }.`[dropLastWhile][ColumnSet.dropLastWhile]` { it.`[name][ColumnWithPath.name]`.`[startsWith][String.startsWith]`("my") } }`
+     *
+     * @param [predicate] The [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter] to control which columns to drop.
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing the last columns adhering to the [predicate].
+     */
+    public fun <C> ColumnSet<C>.dropLastWhile(predicate: ColumnFilter<C>): ColumnSet<C> =
+        transform { it.dropLastWhile(predicate) }
+
+    /**
+     * ## Drop Last (Cols) While
+     * This function drops the last columns from [this] adhering to the
+     * given [predicate] collecting the result into a [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet].
+     *
+     * This function operates solely on columns at the top-level.
+     *
+     * Any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi] can be used as receiver for these functions.
+     *
+     * NOTE: To avoid ambiguity, `dropLastWhile` is called
+     * `dropLastColsWhile` when called on a [String] or [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath] resembling
+     * a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * ### Check out: [Usage]
+     *
+     * #### Examples:
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { `[`cols`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]` { "my" `[`in`][String.contains]` it.`[`name`][org.jetbrains.kotlinx.dataframe.DataColumn.name]` }.`[`dropLastWhile`][ColumnSet.dropLastWhile]` { "my" `[`in`][String.contains]` it.`[`name`][org.jetbrains.kotlinx.dataframe.DataColumn.name]` } }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[`dropLastWhile`][SingleColumn.dropLastColsWhile]` { it.`[`any`][org.jetbrains.kotlinx.dataframe.DataColumn.any]` { it == "Alice" } } }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "myColumnGroup".`[`dropLastColsWhile`][String.dropLastColsWhile]` { it.`[`kind`][org.jetbrains.kotlinx.dataframe.DataColumn.kind]`() == `[`ColumnKind.Value`][org.jetbrains.kotlinx.dataframe.columns.ColumnKind.Value]` } }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][DataFrame.select]`  {  `[dropLastWhile][ColumnsSelectionDsl.dropLastWhile]` { it.`[any][ColumnWithPath.any]` { it == "Alice" } } }`
+     *
+     * @param [predicate] The [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter] to control which columns to drop.
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing the last columns adhering to the [predicate].
+     */
+    public fun ColumnsSelectionDsl<*>.dropLastWhile(predicate: ColumnFilter<*>): ColumnSet<*> =
+        this.asSingleColumn().dropLastColsWhile(predicate)
+
+    /**
+     * ## Drop Last (Cols) While
+     * This function drops the last columns from [this] adhering to the
+     * given [predicate] collecting the result into a [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet].
+     *
+     * This function operates solely on columns at the top-level.
+     *
+     * Any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi] can be used as receiver for these functions.
+     *
+     * NOTE: To avoid ambiguity, `dropLastWhile` is called
+     * `dropLastColsWhile` when called on a [String] or [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath] resembling
+     * a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * ### Check out: [Usage]
+     *
+     * #### Examples:
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { `[`cols`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]` { "my" `[`in`][String.contains]` it.`[`name`][org.jetbrains.kotlinx.dataframe.DataColumn.name]` }.`[`dropLastWhile`][ColumnSet.dropLastWhile]` { "my" `[`in`][String.contains]` it.`[`name`][org.jetbrains.kotlinx.dataframe.DataColumn.name]` } }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[`dropLastWhile`][SingleColumn.dropLastColsWhile]` { it.`[`any`][org.jetbrains.kotlinx.dataframe.DataColumn.any]` { it == "Alice" } } }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "myColumnGroup".`[`dropLastColsWhile`][String.dropLastColsWhile]` { it.`[`kind`][org.jetbrains.kotlinx.dataframe.DataColumn.kind]`() == `[`ColumnKind.Value`][org.jetbrains.kotlinx.dataframe.columns.ColumnKind.Value]` } }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][DataFrame.select]` { myColumnGroup.`[dropLastColsWhile][SingleColumn.dropLastColsWhile]` { it.`[name][ColumnWithPath.name]`.`[startsWith][String.startsWith]`("my") } }`
+     *
+     * @param [predicate] The [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter] to control which columns to drop.
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing the last columns adhering to the [predicate].
+     */
+    public fun SingleColumn<DataRow<*>>.dropLastColsWhile(predicate: ColumnFilter<*>): ColumnSet<*> =
+        this.ensureIsColumnGroup().transformSingle { it.cols().dropLastWhile(predicate) }
+
+    /**
+     * ## Drop Last (Cols) While
+     * This function drops the last columns from [this] adhering to the
+     * given [predicate] collecting the result into a [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet].
+     *
+     * This function operates solely on columns at the top-level.
+     *
+     * Any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi] can be used as receiver for these functions.
+     *
+     * NOTE: To avoid ambiguity, `dropLastWhile` is called
+     * `dropLastColsWhile` when called on a [String] or [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath] resembling
+     * a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * ### Check out: [Usage]
+     *
+     * #### Examples:
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { `[`cols`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]` { "my" `[`in`][String.contains]` it.`[`name`][org.jetbrains.kotlinx.dataframe.DataColumn.name]` }.`[`dropLastWhile`][ColumnSet.dropLastWhile]` { "my" `[`in`][String.contains]` it.`[`name`][org.jetbrains.kotlinx.dataframe.DataColumn.name]` } }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[`dropLastWhile`][SingleColumn.dropLastColsWhile]` { it.`[`any`][org.jetbrains.kotlinx.dataframe.DataColumn.any]` { it == "Alice" } } }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "myColumnGroup".`[`dropLastColsWhile`][String.dropLastColsWhile]` { it.`[`kind`][org.jetbrains.kotlinx.dataframe.DataColumn.kind]`() == `[`ColumnKind.Value`][org.jetbrains.kotlinx.dataframe.columns.ColumnKind.Value]` } }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][DataFrame.select]` { "myColumnGroup".`[dropLastColsWhile][String.dropLastColsWhile]` { it.`[name][ColumnWithPath.name]`.`[startsWith][String.startsWith]`("my") } }`
+     *
+     * @param [predicate] The [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter] to control which columns to drop.
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing the last columns adhering to the [predicate].
+     */
+    public fun String.dropLastColsWhile(predicate: ColumnFilter<*>): ColumnSet<*> =
+        columnGroup(this).dropLastColsWhile(predicate)
+
+    /**
+     * ## Drop Last (Cols) While
+     * This function drops the last columns from [this] adhering to the
+     * given [predicate] collecting the result into a [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet].
+     *
+     * This function operates solely on columns at the top-level.
+     *
+     * Any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi] can be used as receiver for these functions.
+     *
+     * NOTE: To avoid ambiguity, `dropLastWhile` is called
+     * `dropLastColsWhile` when called on a [String] or [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath] resembling
+     * a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * ### Check out: [Usage]
+     *
+     * #### Examples:
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { `[`cols`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]` { "my" `[`in`][String.contains]` it.`[`name`][org.jetbrains.kotlinx.dataframe.DataColumn.name]` }.`[`dropLastWhile`][ColumnSet.dropLastWhile]` { "my" `[`in`][String.contains]` it.`[`name`][org.jetbrains.kotlinx.dataframe.DataColumn.name]` } }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[`dropLastWhile`][SingleColumn.dropLastColsWhile]` { it.`[`any`][org.jetbrains.kotlinx.dataframe.DataColumn.any]` { it == "Alice" } } }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "myColumnGroup".`[`dropLastColsWhile`][String.dropLastColsWhile]` { it.`[`kind`][org.jetbrains.kotlinx.dataframe.DataColumn.kind]`() == `[`ColumnKind.Value`][org.jetbrains.kotlinx.dataframe.columns.ColumnKind.Value]` } }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][DataFrame.select]` { Type::myColumnGroup.`[dropLastColsWhile][SingleColumn.dropLastColsWhile]` { it.`[name][ColumnWithPath.name]`.`[startsWith][String.startsWith]`("my") } }`
+     *
+     * `df.`[select][DataFrame.select]` { DataSchemaType::myColumnGroup.`[dropLastColsWhile][KProperty.dropLastColsWhile]` { it.`[any][ColumnWithPath.any]` { it == "Alice" } } }`
+     *
+     * @param [predicate] The [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter] to control which columns to drop.
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing the last columns adhering to the [predicate].
+     */
+    public fun KProperty<*>.dropLastColsWhile(predicate: ColumnFilter<*>): ColumnSet<*> =
+        columnGroup(this).dropLastColsWhile(predicate)
+
+    /**
+     * ## Drop Last (Cols) While
+     * This function drops the last columns from [this] adhering to the
+     * given [predicate] collecting the result into a [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet].
+     *
+     * This function operates solely on columns at the top-level.
+     *
+     * Any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi] can be used as receiver for these functions.
+     *
+     * NOTE: To avoid ambiguity, `dropLastWhile` is called
+     * `dropLastColsWhile` when called on a [String] or [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath] resembling
+     * a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * ### Check out: [Usage]
+     *
+     * #### Examples:
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { `[`cols`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]` { "my" `[`in`][String.contains]` it.`[`name`][org.jetbrains.kotlinx.dataframe.DataColumn.name]` }.`[`dropLastWhile`][ColumnSet.dropLastWhile]` { "my" `[`in`][String.contains]` it.`[`name`][org.jetbrains.kotlinx.dataframe.DataColumn.name]` } }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[`dropLastWhile`][SingleColumn.dropLastColsWhile]` { it.`[`any`][org.jetbrains.kotlinx.dataframe.DataColumn.any]` { it == "Alice" } } }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "myColumnGroup".`[`dropLastColsWhile`][String.dropLastColsWhile]` { it.`[`kind`][org.jetbrains.kotlinx.dataframe.DataColumn.kind]`() == `[`ColumnKind.Value`][org.jetbrains.kotlinx.dataframe.columns.ColumnKind.Value]` } }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][DataFrame.select]` { "pathTo"["myColumnGroup"].`[dropLastColsWhile][ColumnPath.dropLastColsWhile]` { it.`[name][ColumnWithPath.name]`.`[startsWith][String.startsWith]`("my") } }`
+     *
+     * @param [predicate] The [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter] to control which columns to drop.
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing the last columns adhering to the [predicate].
+     */
+    public fun ColumnPath.dropLastColsWhile(predicate: ColumnFilter<*>): ColumnSet<*> =
+        columnGroup(this).dropLastColsWhile(predicate)
+
+    // endregion
+}
+
+// endregion
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/duplicate.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/duplicate.kt
new file mode 100644
index 000000000..4727b9602
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/duplicate.kt
@@ -0,0 +1,17 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.DataRow
+import org.jetbrains.kotlinx.dataframe.RowFilter
+import org.jetbrains.kotlinx.dataframe.columns.FrameColumn
+import org.jetbrains.kotlinx.dataframe.impl.api.duplicateImpl
+import org.jetbrains.kotlinx.dataframe.impl.api.duplicateRowsImpl
+
+public fun <T> DataFrame<T>.duplicate(n: Int): FrameColumn<T> = List(n) { this }.toFrameColumn()
+
+public fun <T> DataFrame<T>.duplicateRows(n: Int): DataFrame<T> = duplicateRowsImpl(n)
+
+public fun <T> DataFrame<T>.duplicateRows(n: Int, filter: RowFilter<T>): DataFrame<T> =
+    duplicateRowsImpl(n, rows().filter { filter(it, it) }.map { it.index() })
+
+public fun <T> DataRow<T>.duplicate(n: Int): DataFrame<T> = duplicateImpl(n)
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/enum.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/enum.kt
new file mode 100644
index 000000000..76fbe6ca7
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/enum.kt
@@ -0,0 +1,11 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+/**
+ * Make your enum class inherit [DataSchemaEnum] to
+ * make String -> Enum and Enum -> String conversions work
+ * using [value] instead of the enum name.
+ * (Fallback to enum name if the value cannot be found is implemented)
+ */
+public interface DataSchemaEnum {
+    public val value: String
+}
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/explode.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/explode.kt
new file mode 100644
index 000000000..926b8a723
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/explode.kt
@@ -0,0 +1,62 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import org.jetbrains.kotlinx.dataframe.ColumnsSelector
+import org.jetbrains.kotlinx.dataframe.DataColumn
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.DataRow
+import org.jetbrains.kotlinx.dataframe.annotations.Interpretable
+import org.jetbrains.kotlinx.dataframe.annotations.Refine
+import org.jetbrains.kotlinx.dataframe.columns.ColumnGroup
+import org.jetbrains.kotlinx.dataframe.columns.ColumnReference
+import org.jetbrains.kotlinx.dataframe.columns.toColumnSet
+import org.jetbrains.kotlinx.dataframe.impl.api.explodeImpl
+import kotlin.reflect.KProperty
+
+private val defaultExplodeColumns: ColumnsSelector<*, *> = { colsAtAnyDepth { it.isList() || it.isFrameColumn() } }
+
+// region explode DataFrame
+@Refine
+@Interpretable("Explode0")
+public fun <T> DataFrame<T>.explode(
+    dropEmpty: Boolean = true,
+    selector: ColumnsSelector<T, *> = defaultExplodeColumns,
+): DataFrame<T> = explodeImpl(dropEmpty, selector)
+
+public fun <T> DataFrame<T>.explode(vararg columns: String, dropEmpty: Boolean = true): DataFrame<T> =
+    explode(dropEmpty) { columns.toColumnSet() }
+
+public fun <T, C> DataFrame<T>.explode(vararg columns: ColumnReference<C>, dropEmpty: Boolean = true): DataFrame<T> =
+    explode(dropEmpty) { columns.toColumnSet() }
+
+public fun <T, C> DataFrame<T>.explode(vararg columns: KProperty<C>, dropEmpty: Boolean = true): DataFrame<T> =
+    explode(dropEmpty) { columns.toColumnSet() }
+
+// endregion
+
+// region explode DataRow
+
+public fun <T> DataRow<T>.explode(
+    dropEmpty: Boolean = true,
+    selector: ColumnsSelector<T, *> = defaultExplodeColumns,
+): DataFrame<T> = toDataFrame().explode(dropEmpty, selector)
+
+public fun <T> DataRow<T>.explode(vararg columns: String, dropEmpty: Boolean = true): DataFrame<T> =
+    explode(dropEmpty) { columns.toColumnSet() }
+
+public fun <T, C> DataRow<T>.explode(vararg columns: ColumnReference<C>, dropEmpty: Boolean = true): DataFrame<T> =
+    explode(dropEmpty) { columns.toColumnSet() }
+
+public fun <T, C> DataRow<T>.explode(vararg columns: KProperty<C>, dropEmpty: Boolean = true): DataFrame<T> =
+    explode(dropEmpty) { columns.toColumnSet() }
+
+// endregion
+
+// region explode DataColumn
+
+@JvmName("explodeList")
+public fun <T> DataColumn<Collection<T>>.explode(): DataColumn<T> = explodeImpl() as DataColumn<T>
+
+@JvmName("explodeFrames")
+public fun <T> DataColumn<DataFrame<T>>.explode(): ColumnGroup<T> = concat().asColumnGroup(name())
+
+// endregion
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/expr.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/expr.kt
new file mode 100644
index 000000000..6c26342a4
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/expr.kt
@@ -0,0 +1,99 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import org.jetbrains.kotlinx.dataframe.ColumnsContainer
+import org.jetbrains.kotlinx.dataframe.DataColumn
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.annotations.Interpretable
+import org.jetbrains.kotlinx.dataframe.api.ExprColumnsSelectionDsl.Grammar
+import org.jetbrains.kotlinx.dataframe.documentation.ColumnExpression
+
+// region ColumnsSelectionDsl
+
+/**
+ * ## Expr [Columns Selection DSL][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl]
+ *
+ * See [Grammar] for all functions in this interface.
+ */
+public interface ExprColumnsSelectionDsl {
+
+    /**
+     * ## Expr Grammar
+     *
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * [(What is this notation?)][org.jetbrains.kotlinx.dataframe.documentation.DslGrammar]
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  ### Definitions:
+     *  `name: `[`String`][String]
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  `infer: `[`Infer`][org.jetbrains.kotlinx.dataframe.api.Infer]
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  `expression: `[Column Expression][org.jetbrains.kotlinx.dataframe.documentation.ColumnExpression]
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  ### What can be called directly in the [Columns Selection DSL][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl]:
+     *
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  [**`expr`**][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.expr]**`(`**`[`[`name`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.NameDef]**`,`**`][`[`infer`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.InferDef]`]`**`) { `**[`expression`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ColumnExpressionDef]**` }`**
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     */
+    public interface Grammar {
+
+        /** [**`expr`**][ColumnsSelectionDsl.expr] */
+        public interface PlainDslName
+    }
+}
+
+/**
+ * ## Column Expression
+ * Create a temporary new column by defining an expression to fill up each row.
+ *
+ * See [Column Expression][org.jetbrains.kotlinx.dataframe.documentation.ColumnExpression] for more information.
+ *
+ * This function is essentially a shortcut for [ColumnsContainer.mapToColumn].
+ *
+ * ### Check out: [Usage][ExprColumnsSelectionDsl.Grammar]
+ *
+ * #### For example:
+ *
+ * `df.`[groupBy][DataFrame.groupBy]`  {  `[`expr`][ColumnsSelectionDsl.expr]` { firstName.`[`length`][String.length]` + lastName.`[`length`][String.length]`  }  `[`named`][named]` "nameLength" }`
+ *
+ * `df.`[sortBy][DataFrame.sortBy]`  {  `[`expr`][ColumnsSelectionDsl.expr]` { name.`[`length`][String.length]` }.`[`desc`][SortDsl.desc]`() }`
+ *
+ * @param [name] The name the temporary column. Is empty by default ("untitled" in the DataFrame).
+ * @param [infer] [An enum][org.jetbrains.kotlinx.dataframe.api.Infer.Infer] that indicates how [DataColumn.type][org.jetbrains.kotlinx.dataframe.DataColumn.type] should be calculated.
+ * Either [None][org.jetbrains.kotlinx.dataframe.api.Infer.None], [Nulls][org.jetbrains.kotlinx.dataframe.api.Infer.Nulls], or [Type][org.jetbrains.kotlinx.dataframe.api.Infer.Type]. By default: [Nulls][Infer.Nulls].
+ * @param [expression] An [AddExpression] to define what each new row of the temporary column should contain.
+ * @see [ColumnsContainer.mapToColumn]
+ */
+@Interpretable("Expr0")
+public inline fun <T, reified R> ColumnsSelectionDsl<T>.expr(
+    name: String = "",
+    infer: Infer = Infer.Nulls,
+    noinline expression: AddExpression<T, R>,
+): DataColumn<R> = mapToColumn(name, infer, expression)
+
+// endregion
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/filter.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/filter.kt
new file mode 100644
index 000000000..06c410ee0
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/filter.kt
@@ -0,0 +1,141 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import org.jetbrains.kotlinx.dataframe.ColumnFilter
+import org.jetbrains.kotlinx.dataframe.ColumnSelector
+import org.jetbrains.kotlinx.dataframe.ColumnsSelector
+import org.jetbrains.kotlinx.dataframe.DataColumn
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.Predicate
+import org.jetbrains.kotlinx.dataframe.RowFilter
+import org.jetbrains.kotlinx.dataframe.columns.ColumnPath
+import org.jetbrains.kotlinx.dataframe.columns.ColumnReference
+import org.jetbrains.kotlinx.dataframe.columns.ColumnSet
+import org.jetbrains.kotlinx.dataframe.columns.ColumnWithPath
+import org.jetbrains.kotlinx.dataframe.columns.SingleColumn
+import org.jetbrains.kotlinx.dataframe.columns.asColumnSet
+import org.jetbrains.kotlinx.dataframe.impl.columns.TransformableColumnSet
+import org.jetbrains.kotlinx.dataframe.impl.getTrueIndices
+import org.jetbrains.kotlinx.dataframe.indices
+import kotlin.reflect.KProperty
+
+// region DataColumn
+
+public fun <T> DataColumn<T>.filter(predicate: Predicate<T>): DataColumn<T> =
+    indices
+        .filter { predicate(get(it)) }
+        .let { get(it) }
+
+// endregion
+
+// region DataFrame
+
+public fun <T> DataFrame<T>.filter(predicate: RowFilter<T>): DataFrame<T> =
+    indices.filter {
+        val row = get(it)
+        predicate(row, row)
+    }.let { get(it) }
+
+public fun <T> DataFrame<T>.filterBy(column: ColumnSelector<T, Boolean>): DataFrame<T> =
+    getRows(getColumn(column).toList().getTrueIndices())
+
+public fun <T> DataFrame<T>.filterBy(column: String): DataFrame<T> = filterBy { column.toColumnOf() }
+
+public fun <T> DataFrame<T>.filterBy(column: ColumnReference<Boolean>): DataFrame<T> = filterBy { column }
+
+public fun <T> DataFrame<T>.filterBy(column: KProperty<Boolean>): DataFrame<T> = filterBy { column.toColumnAccessor() }
+
+// endregion
+
+internal fun <T, C> ColumnsSelector<T, C>.filter(predicate: (ColumnWithPath<C>) -> Boolean): ColumnsSelector<T, C> =
+    { this@filter(it).asColumnSet().filter(predicate) }
+
+// region ColumnsSelectionDsl
+
+/**
+ * ## Filter [ColumnSet] [Columns Selection DSL][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl]
+ *
+ * See [Grammar] for all functions in this interface.
+ */
+public interface FilterColumnsSelectionDsl {
+
+    /**
+     * ## Filter [ColumnSet] Grammar
+     *
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * [(What is this notation?)][org.jetbrains.kotlinx.dataframe.documentation.DslGrammar]
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  ### Definitions:
+     *  `columnSet: `[`ColumnSet`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]`<*>`
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  `condition: `[`ColumnFilter`][org.jetbrains.kotlinx.dataframe.ColumnFilter]
+     *
+     *
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  ### What can be called on a [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]:
+     *
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  [`columnSet`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ColumnSetDef]
+     *
+     *  &nbsp;&nbsp;&nbsp;&nbsp;__`.`__[**`filter`**][org.jetbrains.kotlinx.dataframe.api.FilterColumnsSelectionDsl.filter]**` { `**[`condition`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ConditionDef]**` }`**
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     */
+    public interface Grammar {
+
+        /** __`.`__[**`filter`**][ColumnsSelectionDsl.filter] */
+        public interface ColumnSetName
+    }
+
+    /**
+     * ## Filter [ColumnSet]
+     *
+     * Creates a subset of columns ([ColumnSet]) from the current [ColumnSet] that
+     * adhere to the given [predicate].
+     *
+     * Aside from calling [filter][ColumnSet.filter] directly, you can also use the [get][ColumnsSelectionDsl.get] operator
+     * in most cases. This function belongs to [cols][ColumnsSelectionDsl.cols] but operates identically.
+     *
+     * ### Check out: [Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[`remove`][DataFrame.remove]`  {  `[`all`][ColumnsSelectionDsl.all]`().`[`filter`][ColumnSet.filter]` { it.`[`hasNulls`][DataColumn.hasNulls]`() } }`
+     *
+     * `// and although this can be shortened to just the `[`colsOf`][colsOf]` call:`
+     *
+     * `df.`[`select`][DataFrame.select]`  {  `[`colsOf`][colsOf]`<`[`String`][String]`>().`[`filter`][ColumnSet.filter]`  { "e"  `[`in`][String.contains]` it.`[`name`][ColumnPath.name]`() } }`
+     *
+     * `df.`[`select`][DataFrame.select]`  {  `[`colsOf`][SingleColumn.colsOf]`<`[`String`][String]`>()`[`[`][ColumnsSelectionDsl.cols]`{ it.`[`any`][ColumnWithPath.any]` { it == "Alice" } }`[`]`][ColumnsSelectionDsl.cols]` }`
+     *
+     * @param [predicate] A [ColumnFilter function][ColumnFilter] that takes a [ColumnReference] and returns a [Boolean].
+     * @return A [ColumnSet] containing the columns that match the given [predicate].
+     * @see [ColumnsSelectionDsl.cols]
+     */
+    @Suppress("UNCHECKED_CAST")
+    public fun <C> ColumnSet<C>.filter(predicate: ColumnFilter<C>): TransformableColumnSet<C> =
+        colsInternal(predicate as ColumnFilter<*>) as TransformableColumnSet<C>
+}
+
+// endregion
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/first.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/first.kt
new file mode 100644
index 000000000..bbfd66d75
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/first.kt
@@ -0,0 +1,391 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import org.jetbrains.kotlinx.dataframe.ColumnFilter
+import org.jetbrains.kotlinx.dataframe.DataColumn
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.DataRow
+import org.jetbrains.kotlinx.dataframe.RowFilter
+import org.jetbrains.kotlinx.dataframe.api.FirstColumnsSelectionDsl.Grammar
+import org.jetbrains.kotlinx.dataframe.columns.ColumnGroup
+import org.jetbrains.kotlinx.dataframe.columns.ColumnPath
+import org.jetbrains.kotlinx.dataframe.columns.ColumnReference
+import org.jetbrains.kotlinx.dataframe.columns.ColumnSet
+import org.jetbrains.kotlinx.dataframe.columns.SingleColumn
+import org.jetbrains.kotlinx.dataframe.columns.asColumnSet
+import org.jetbrains.kotlinx.dataframe.columns.size
+import org.jetbrains.kotlinx.dataframe.columns.values
+import org.jetbrains.kotlinx.dataframe.impl.columns.TransformableColumnSet
+import org.jetbrains.kotlinx.dataframe.impl.columns.TransformableSingleColumn
+import org.jetbrains.kotlinx.dataframe.impl.columns.singleOrNullWithTransformerImpl
+import org.jetbrains.kotlinx.dataframe.impl.columns.transform
+import org.jetbrains.kotlinx.dataframe.nrow
+import kotlin.reflect.KProperty
+
+// region DataColumn
+
+public fun <T> DataColumn<T>.first(): T = get(0)
+
+public fun <T> DataColumn<T>.firstOrNull(): T? = if (size > 0) first() else null
+
+public fun <T> DataColumn<T>.first(predicate: (T) -> Boolean): T = values.first(predicate)
+
+public fun <T> DataColumn<T>.firstOrNull(predicate: (T) -> Boolean): T? = values.firstOrNull(predicate)
+
+// endregion
+
+// region DataFrame
+
+public fun <T> DataFrame<T>.first(): DataRow<T> {
+    if (nrow == 0) {
+        throw NoSuchElementException("DataFrame has no rows. Use `firstOrNull`.")
+    }
+    return get(0)
+}
+
+public fun <T> DataFrame<T>.firstOrNull(): DataRow<T>? = if (nrow > 0) first() else null
+
+public fun <T> DataFrame<T>.first(predicate: RowFilter<T>): DataRow<T> = rows().first { predicate(it, it) }
+
+public fun <T> DataFrame<T>.firstOrNull(predicate: RowFilter<T>): DataRow<T>? = rows().firstOrNull { predicate(it, it) }
+
+// endregion
+
+// region GroupBy
+
+public fun <T, G> GroupBy<T, G>.first(): ReducedGroupBy<T, G> = reduce { firstOrNull() }
+
+public fun <T, G> GroupBy<T, G>.first(predicate: RowFilter<G>): ReducedGroupBy<T, G> = reduce { firstOrNull(predicate) }
+
+// endregion
+
+// region Pivot
+
+public fun <T> Pivot<T>.first(): ReducedPivot<T> = reduce { firstOrNull() }
+
+public fun <T> Pivot<T>.first(predicate: RowFilter<T>): ReducedPivot<T> = reduce { firstOrNull(predicate) }
+
+// endregion
+
+// region PivotGroupBy
+
+public fun <T> PivotGroupBy<T>.first(): ReducedPivotGroupBy<T> = reduce { firstOrNull() }
+
+public fun <T> PivotGroupBy<T>.first(predicate: RowFilter<T>): ReducedPivotGroupBy<T> =
+    reduce { firstOrNull(predicate) }
+
+// endregion
+
+// region ColumnsSelectionDsl
+
+/**
+ * ## First (Col) [Columns Selection DSL][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl]
+ *
+ * See [Grammar] for all functions in this interface.
+ */
+public interface FirstColumnsSelectionDsl {
+
+    /**
+     * ## First (Col) Grammar
+     *
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * [(What is this notation?)][org.jetbrains.kotlinx.dataframe.documentation.DslGrammar]
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  ### Definitions:
+     *  `columnSet: `[`ColumnSet`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]`<*>`
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  `columnGroup: `[`SingleColumn`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]`<`[`DataRow`][org.jetbrains.kotlinx.dataframe.DataRow]`<*>> | `[`String`][String]`  |  `[`KProperty`][kotlin.reflect.KProperty]`<* | `[`DataRow`][org.jetbrains.kotlinx.dataframe.DataRow]`<*>> | `[`ColumnPath`][org.jetbrains.kotlinx.dataframe.columns.ColumnPath]
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  `condition: `[`ColumnFilter`][org.jetbrains.kotlinx.dataframe.ColumnFilter]
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  ### What can be called directly in the [Columns Selection DSL][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl]:
+     *
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  [**`first`**][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.first]`  [  `**`{ `**[`condition`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ConditionDef]**` }`**` ]`
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  ### What can be called on a [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]:
+     *
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  [`columnSet`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ColumnSetDef]
+     *
+     *  &nbsp;&nbsp;&nbsp;&nbsp;__`.`__[**`first`**][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.first]`  [  `**`{ `**[`condition`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ConditionDef]**` }`**` ]`
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  ### What can be called on a [Column Group (reference)][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ColumnGroupDef]:
+     *
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  [`columnGroup`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ColumnGroupDef]
+     *
+     *  &nbsp;&nbsp;&nbsp;&nbsp;__`.`__[**`firstCol`**][org.jetbrains.kotlinx.dataframe.api.FirstColumnsSelectionDsl.firstCol]`  [  `**`{ `**[`condition`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ConditionDef]**` }`**` ]`
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     */
+    public interface Grammar {
+
+        /** [**`first`**][ColumnsSelectionDsl.first] */
+        public interface PlainDslName
+
+        /** __`.`__[**`first`**][ColumnsSelectionDsl.first] */
+        public interface ColumnSetName
+
+        /** __`.`__[**`firstCol`**][ColumnsSelectionDsl.firstCol] */
+        public interface ColumnGroupName
+    }
+
+    /**
+     * ## First (Col)
+     *
+     * Returns the first column from [this] that adheres to the optional given [condition].
+     * If no column adheres to the given [condition], [NoSuchElementException] is thrown.
+     *
+     * This function operates solely on columns at the top-level.
+     *
+     * NOTE: For [column groups][ColumnGroup], `first` is named `firstCol` instead to avoid confusion.
+     *
+     * ### Check out: [Grammar]
+     *
+     * #### Examples:
+     *
+     * `df.`[select][DataFrame.select]`  {  `[first][ColumnsSelectionDsl.first]` { it.`[name][ColumnReference.name]`().`[startsWith][String.startsWith]`("order") } }`
+     *
+     * `df.`[select][DataFrame.select]` { "myColumnGroup".`[firstCol][String.firstCol]` { it.`[name][ColumnReference.name]`().`[startsWith][String.startsWith]`("year") } }`
+     *
+     * #### Examples for this overload:
+     *
+     *
+     *
+     * @param [condition] The optional [ColumnFilter] condition that the column must adhere to.
+     * @return A [SingleColumn] containing the first column
+     *   that adheres to the given [condition].
+     * @throws [NoSuchElementException] if no column adheres to the given [condition].
+     * @see [ColumnsSelectionDsl.last]
+     */
+    private interface CommonFirstDocs {
+
+        /** Examples key */
+        interface Examples
+    }
+
+    /**
+     * ## First (Col)
+     *
+     * Returns the first column from [this] that adheres to the optional given [condition].
+     * If no column adheres to the given [condition], [NoSuchElementException] is thrown.
+     *
+     * This function operates solely on columns at the top-level.
+     *
+     * NOTE: For [column groups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup], `first` is named `firstCol` instead to avoid confusion.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.FirstColumnsSelectionDsl.Grammar]
+     *
+     * #### Examples:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[first][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.first]` { it.`[name][org.jetbrains.kotlinx.dataframe.columns.ColumnReference.name]`().`[startsWith][String.startsWith]`("order") } }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "myColumnGroup".`[firstCol][kotlin.String.firstCol]` { it.`[name][org.jetbrains.kotlinx.dataframe.columns.ColumnReference.name]`().`[startsWith][String.startsWith]`("year") } }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][DataFrame.select]`  {  `[colsOf][SingleColumn.colsOf]`<`[String][String]`>().`[first][ColumnSet.first]` { it.`[name][ColumnReference.name]`().`[startsWith][String.startsWith]`("year") } }`
+     *
+     * `df.`[select][DataFrame.select]`  {  `[colsOf][SingleColumn.colsOf]`<`[Int][Int]`>().`[first][ColumnSet.first]`() }`
+     *
+     * @param [condition] The optional [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter] condition that the column must adhere to.
+     * @return A [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn] containing the first column
+     *   that adheres to the given [condition].
+     * @throws [NoSuchElementException] if no column adheres to the given [condition].
+     * @see [ColumnsSelectionDsl.last]
+     */
+    @Suppress("UNCHECKED_CAST")
+    public fun <C> ColumnSet<C>.first(condition: ColumnFilter<C> = { true }): TransformableSingleColumn<C> =
+        (allColumnsInternal() as TransformableColumnSet<C>)
+            .transform { listOf(it.first(condition)) }
+            .singleOrNullWithTransformerImpl()
+
+    /**
+     * ## First (Col)
+     *
+     * Returns the first column from [this] that adheres to the optional given [condition].
+     * If no column adheres to the given [condition], [NoSuchElementException] is thrown.
+     *
+     * This function operates solely on columns at the top-level.
+     *
+     * NOTE: For [column groups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup], `first` is named `firstCol` instead to avoid confusion.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.FirstColumnsSelectionDsl.Grammar]
+     *
+     * #### Examples:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[first][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.first]` { it.`[name][org.jetbrains.kotlinx.dataframe.columns.ColumnReference.name]`().`[startsWith][String.startsWith]`("order") } }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "myColumnGroup".`[firstCol][kotlin.String.firstCol]` { it.`[name][org.jetbrains.kotlinx.dataframe.columns.ColumnReference.name]`().`[startsWith][String.startsWith]`("year") } }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][DataFrame.select]`  {  `[first][ColumnsSelectionDsl.first]` { it.`[name][ColumnReference.name]`().`[startsWith][String.startsWith]`("year") } }`
+     *
+     * @param [condition] The optional [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter] condition that the column must adhere to.
+     * @return A [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn] containing the first column
+     *   that adheres to the given [condition].
+     * @throws [NoSuchElementException] if no column adheres to the given [condition].
+     * @see [ColumnsSelectionDsl.last]
+     */
+    public fun ColumnsSelectionDsl<*>.first(condition: ColumnFilter<*> = { true }): TransformableSingleColumn<*> =
+        asSingleColumn().firstCol(condition)
+
+    /**
+     * ## First (Col)
+     *
+     * Returns the first column from [this] that adheres to the optional given [condition].
+     * If no column adheres to the given [condition], [NoSuchElementException] is thrown.
+     *
+     * This function operates solely on columns at the top-level.
+     *
+     * NOTE: For [column groups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup], `first` is named `firstCol` instead to avoid confusion.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.FirstColumnsSelectionDsl.Grammar]
+     *
+     * #### Examples:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[first][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.first]` { it.`[name][org.jetbrains.kotlinx.dataframe.columns.ColumnReference.name]`().`[startsWith][String.startsWith]`("order") } }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "myColumnGroup".`[firstCol][kotlin.String.firstCol]` { it.`[name][org.jetbrains.kotlinx.dataframe.columns.ColumnReference.name]`().`[startsWith][String.startsWith]`("year") } }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][DataFrame.select]` { myColumnGroup.`[firstCol][SingleColumn.firstCol]`() }`
+     *
+     * @param [condition] The optional [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter] condition that the column must adhere to.
+     * @return A [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn] containing the first column
+     *   that adheres to the given [condition].
+     * @throws [NoSuchElementException] if no column adheres to the given [condition].
+     * @see [ColumnsSelectionDsl.last]
+     */
+    public fun SingleColumn<DataRow<*>>.firstCol(condition: ColumnFilter<*> = { true }): TransformableSingleColumn<*> =
+        this.ensureIsColumnGroup().asColumnSet().first(condition)
+
+    /**
+     * ## First (Col)
+     *
+     * Returns the first column from [this] that adheres to the optional given [condition].
+     * If no column adheres to the given [condition], [NoSuchElementException] is thrown.
+     *
+     * This function operates solely on columns at the top-level.
+     *
+     * NOTE: For [column groups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup], `first` is named `firstCol` instead to avoid confusion.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.FirstColumnsSelectionDsl.Grammar]
+     *
+     * #### Examples:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[first][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.first]` { it.`[name][org.jetbrains.kotlinx.dataframe.columns.ColumnReference.name]`().`[startsWith][String.startsWith]`("order") } }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "myColumnGroup".`[firstCol][kotlin.String.firstCol]` { it.`[name][org.jetbrains.kotlinx.dataframe.columns.ColumnReference.name]`().`[startsWith][String.startsWith]`("year") } }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][DataFrame.select]` { "myColumnGroup".`[firstCol][String.firstCol]` { it.`[name][ColumnReference.name]`().`[startsWith][String.startsWith]`("year") } }`
+     *
+     * @param [condition] The optional [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter] condition that the column must adhere to.
+     * @return A [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn] containing the first column
+     *   that adheres to the given [condition].
+     * @throws [NoSuchElementException] if no column adheres to the given [condition].
+     * @see [ColumnsSelectionDsl.last]
+     */
+    public fun String.firstCol(condition: ColumnFilter<*> = { true }): TransformableSingleColumn<*> =
+        columnGroup(this).firstCol(condition)
+
+    /**
+     * ## First (Col)
+     *
+     * Returns the first column from [this] that adheres to the optional given [condition].
+     * If no column adheres to the given [condition], [NoSuchElementException] is thrown.
+     *
+     * This function operates solely on columns at the top-level.
+     *
+     * NOTE: For [column groups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup], `first` is named `firstCol` instead to avoid confusion.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.FirstColumnsSelectionDsl.Grammar]
+     *
+     * #### Examples:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[first][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.first]` { it.`[name][org.jetbrains.kotlinx.dataframe.columns.ColumnReference.name]`().`[startsWith][String.startsWith]`("order") } }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "myColumnGroup".`[firstCol][kotlin.String.firstCol]` { it.`[name][org.jetbrains.kotlinx.dataframe.columns.ColumnReference.name]`().`[startsWith][String.startsWith]`("year") } }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][DataFrame.select]` { Type::myColumnGroup.`[firstCol][SingleColumn.firstCol]` { it.`[name][ColumnReference.name]`().`[startsWith][String.startsWith]`("year") } }`
+     *
+     * `df.`[select][DataFrame.select]` { DataSchemaType::myColumnGroup.`[firstCol][KProperty.firstCol]`() }`
+     *
+     * @param [condition] The optional [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter] condition that the column must adhere to.
+     * @return A [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn] containing the first column
+     *   that adheres to the given [condition].
+     * @throws [NoSuchElementException] if no column adheres to the given [condition].
+     * @see [ColumnsSelectionDsl.last]
+     */
+    public fun KProperty<*>.firstCol(condition: ColumnFilter<*> = { true }): TransformableSingleColumn<*> =
+        columnGroup(this).firstCol(condition)
+
+    /**
+     * ## First (Col)
+     *
+     * Returns the first column from [this] that adheres to the optional given [condition].
+     * If no column adheres to the given [condition], [NoSuchElementException] is thrown.
+     *
+     * This function operates solely on columns at the top-level.
+     *
+     * NOTE: For [column groups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup], `first` is named `firstCol` instead to avoid confusion.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.FirstColumnsSelectionDsl.Grammar]
+     *
+     * #### Examples:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[first][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.first]` { it.`[name][org.jetbrains.kotlinx.dataframe.columns.ColumnReference.name]`().`[startsWith][String.startsWith]`("order") } }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "myColumnGroup".`[firstCol][kotlin.String.firstCol]` { it.`[name][org.jetbrains.kotlinx.dataframe.columns.ColumnReference.name]`().`[startsWith][String.startsWith]`("year") } }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][DataFrame.select]` { "pathTo"["myColumnGroup"].`[firstCol][ColumnPath.firstCol]` { it.`[name][ColumnReference.name]`().`[startsWith][String.startsWith]`("year") } }`
+     *
+     * @param [condition] The optional [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter] condition that the column must adhere to.
+     * @return A [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn] containing the first column
+     *   that adheres to the given [condition].
+     * @throws [NoSuchElementException] if no column adheres to the given [condition].
+     * @see [ColumnsSelectionDsl.last]
+     */
+    public fun ColumnPath.firstCol(condition: ColumnFilter<*> = { true }): TransformableSingleColumn<*> =
+        columnGroup(this).firstCol(condition)
+}
+
+// endregion
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/forEach.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/forEach.kt
new file mode 100644
index 000000000..155ad6c14
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/forEach.kt
@@ -0,0 +1,30 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import org.jetbrains.kotlinx.dataframe.DataColumn
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.RowExpression
+import org.jetbrains.kotlinx.dataframe.columns.values
+
+// region DataColumn
+
+public inline fun <T> DataColumn<T>.forEach(action: (T) -> Unit): Unit = values().forEach(action)
+
+public inline fun <T> DataColumn<T>.forEachIndexed(action: (Int, T) -> Unit): Unit = values().forEachIndexed(action)
+
+// endregion
+
+// region DataFrame
+
+public inline fun <T> DataFrame<T>.forEach(action: RowExpression<T, Unit>): Unit = rows().forEach { action(it, it) }
+
+// endregion
+
+// region GroupBy
+
+public inline fun <T, G> GroupBy<T, G>.forEach(body: (GroupBy.Entry<T, G>) -> Unit): Unit =
+    keys.forEach { key ->
+        val group = groups[key.index()]
+        body(GroupBy.Entry(key, group))
+    }
+
+// endregion
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/format.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/format.kt
new file mode 100644
index 000000000..9c2465800
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/format.kt
@@ -0,0 +1,158 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import org.jetbrains.kotlinx.dataframe.ColumnsSelector
+import org.jetbrains.kotlinx.dataframe.DataColumn
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.DataRow
+import org.jetbrains.kotlinx.dataframe.RowValueFilter
+import org.jetbrains.kotlinx.dataframe.columns.ColumnReference
+import org.jetbrains.kotlinx.dataframe.columns.toColumnSet
+import org.jetbrains.kotlinx.dataframe.impl.api.MergedAttributes
+import org.jetbrains.kotlinx.dataframe.impl.api.SingleAttribute
+import org.jetbrains.kotlinx.dataframe.impl.api.encode
+import org.jetbrains.kotlinx.dataframe.impl.api.formatImpl
+import org.jetbrains.kotlinx.dataframe.impl.api.linearGradient
+import org.jetbrains.kotlinx.dataframe.io.DataFrameHtmlData
+import org.jetbrains.kotlinx.dataframe.io.DisplayConfiguration
+import org.jetbrains.kotlinx.dataframe.io.toHTML
+import org.jetbrains.kotlinx.dataframe.io.toStandaloneHTML
+import kotlin.reflect.KProperty
+
+// region DataFrame
+
+// region format
+
+public fun <T, C> DataFrame<T>.format(columns: ColumnsSelector<T, C>): FormatClause<T, C> = FormatClause(this, columns)
+
+public fun <T> DataFrame<T>.format(vararg columns: String): FormatClause<T, Any?> = format { columns.toColumnSet() }
+
+public fun <T, C> DataFrame<T>.format(vararg columns: ColumnReference<C>): FormatClause<T, C> =
+    format { columns.toColumnSet() }
+
+public fun <T, C> DataFrame<T>.format(vararg columns: KProperty<C>): FormatClause<T, C> =
+    format { columns.toColumnSet() }
+
+public fun <T> DataFrame<T>.format(): FormatClause<T, Any?> = FormatClause(this)
+
+// endregion
+
+public fun <T, C> FormatClause<T, C>.perRowCol(formatter: RowColFormatter<T, C>): FormattedFrame<T> =
+    formatImpl(formatter)
+
+public fun <T, C> FormatClause<T, C>.with(formatter: CellFormatter<C>): FormattedFrame<T> =
+    formatImpl { row, col -> formatter(row[col]) }
+
+public fun <T, C> FormatClause<T, C>.where(filter: RowValueFilter<T, C>): FormatClause<T, C> =
+    FormatClause(filter = filter, df = df, columns = columns, oldFormatter = oldFormatter)
+
+public fun <T> FormattedFrame<T>.format(): FormatClause<T, Any?> = FormatClause(df, null, formatter)
+
+// endregion
+
+public data class RGBColor(val r: Short, val g: Short, val b: Short)
+
+public interface CellAttributes {
+
+    public fun attributes(): List<Pair<String, String>>
+}
+
+public infix fun CellAttributes?.and(other: CellAttributes?): CellAttributes? =
+    when {
+        other == null -> this
+        this == null -> other
+        else -> MergedAttributes(listOf(this, other))
+    }
+
+public object FormattingDSL {
+    public fun rgb(r: Short, g: Short, b: Short): RGBColor = RGBColor(r, g, b)
+
+    public val black: RGBColor = rgb(0, 0, 0)
+
+    public val white: RGBColor = rgb(255, 255, 255)
+
+    public val green: RGBColor = rgb(0, 255, 0)
+
+    public val red: RGBColor = rgb(255, 0, 0)
+
+    public val blue: RGBColor = rgb(0, 0, 255)
+
+    public val gray: RGBColor = rgb(128, 128, 128)
+
+    public val darkGray: RGBColor = rgb(169, 169, 169)
+
+    public val lightGray: RGBColor = rgb(211, 211, 211)
+
+    public fun attr(name: String, value: String): CellAttributes = SingleAttribute(name, value)
+
+    public fun background(color: RGBColor): CellAttributes = attr("background-color", color.encode())
+
+    public fun background(r: Short, g: Short, b: Short): CellAttributes = background(RGBColor(r, g, b))
+
+    public fun textColor(color: RGBColor): CellAttributes = attr("color", color.encode())
+
+    public fun textColor(r: Short, g: Short, b: Short): CellAttributes = textColor(RGBColor(r, g, b))
+
+    public val italic: CellAttributes = attr("font-style", "italic")
+
+    public val bold: CellAttributes = attr("font-weight", "bold")
+
+    public val underline: CellAttributes = attr("text-decoration", "underline")
+
+    public fun linearBg(value: Number, from: Pair<Number, RGBColor>, to: Pair<Number, RGBColor>): CellAttributes =
+        background(
+            linear(value, from, to),
+        )
+
+    public fun linear(value: Number, from: Pair<Number, RGBColor>, to: Pair<Number, RGBColor>): RGBColor {
+        val a = from.first.toDouble()
+        val b = to.first.toDouble()
+        if (a < b) return linearGradient(value.toDouble(), a, from.second, b, to.second)
+        return linearGradient(value.toDouble(), b, to.second, a, from.second)
+    }
+}
+
+public typealias RowColFormatter<T, C> = FormattingDSL.(DataRow<T>, DataColumn<C>) -> CellAttributes?
+
+public class FormattedFrame<T>(internal val df: DataFrame<T>, internal val formatter: RowColFormatter<T, *>? = null) {
+    /**
+     * @return DataFrameHtmlData without additional definitions. Can be rendered in Jupyter kernel environments
+     */
+    public fun toHTML(configuration: DisplayConfiguration = DisplayConfiguration.DEFAULT): DataFrameHtmlData =
+        df.toHTML(getDisplayConfiguration(configuration))
+
+    /**
+     * @return DataFrameHtmlData with table script and css definitions. Can be saved as an *.html file and displayed in the browser
+     */
+    public fun toStandaloneHTML(configuration: DisplayConfiguration = DisplayConfiguration.DEFAULT): DataFrameHtmlData =
+        df.toStandaloneHTML(getDisplayConfiguration(configuration))
+
+    public fun getDisplayConfiguration(configuration: DisplayConfiguration): DisplayConfiguration =
+        configuration.copy(cellFormatter = formatter as RowColFormatter<*, *>?)
+}
+
+public class FormatClause<T, C>(
+    internal val df: DataFrame<T>,
+    internal val columns: ColumnsSelector<T, C>? = null,
+    internal val oldFormatter: RowColFormatter<T, C>? = null,
+    internal val filter: RowValueFilter<T, C> = { true },
+) {
+    override fun toString(): String =
+        "FormatClause(df=$df, columns=$columns, oldFormatter=$oldFormatter, filter=$filter)"
+}
+
+public fun <T, C> FormattedFrame<T>.format(columns: ColumnsSelector<T, C>): FormatClause<T, C> =
+    FormatClause(df, columns, formatter)
+
+public typealias CellFormatter<V> = FormattingDSL.(V) -> CellAttributes?
+
+public fun <T, C : Number?> FormatClause<T, C>.linearBg(
+    from: Pair<Number, RGBColor>,
+    to: Pair<Number, RGBColor>,
+): FormattedFrame<T> =
+    with {
+        if (it != null) {
+            background(linear(it, from, to))
+        } else {
+            null
+        }
+    }
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/frameCol.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/frameCol.kt
new file mode 100644
index 000000000..1536ac368
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/frameCol.kt
@@ -0,0 +1,3475 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import org.jetbrains.kotlinx.dataframe.AnyColumnGroupAccessor
+import org.jetbrains.kotlinx.dataframe.ColumnGroupReference
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.DataRow
+import org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor
+import org.jetbrains.kotlinx.dataframe.columns.ColumnGroup
+import org.jetbrains.kotlinx.dataframe.columns.ColumnPath
+import org.jetbrains.kotlinx.dataframe.columns.ColumnSet
+import org.jetbrains.kotlinx.dataframe.columns.ColumnWithPath
+import org.jetbrains.kotlinx.dataframe.columns.FrameColumn
+import org.jetbrains.kotlinx.dataframe.columns.SingleColumn
+import org.jetbrains.kotlinx.dataframe.impl.columns.getAt
+import org.jetbrains.kotlinx.dataframe.impl.columns.onResolve
+import org.jetbrains.kotlinx.dataframe.impl.columns.singleImpl
+import org.jetbrains.kotlinx.dataframe.impl.columns.transformSingle
+import kotlin.reflect.KProperty
+
+// region ColumnsSelectionDsl
+
+/**
+ * ## Frame Col [Columns Selection DSL][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl]
+ *
+ * See [Grammar] for all functions in this interface.
+ * @param _UNUSED [#KT-68546](https://youtrack.jetbrains.com/issue/KT-68546/Conflicting-overloads-in-non-generic-interface-K2-2.0.0)
+ */
+public interface FrameColColumnsSelectionDsl<out _UNUSED> {
+
+    /**
+     * ## Frame Col Grammar
+     *
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * [(What is this notation?)][org.jetbrains.kotlinx.dataframe.documentation.DslGrammar]
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  ### Definitions:
+     *  `columnSet: `[`ColumnSet`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]`<*>`
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  `columnGroup: `[`SingleColumn`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]`<`[`DataRow`][org.jetbrains.kotlinx.dataframe.DataRow]`<*>> | `[`String`][String]`  |  `[`KProperty`][kotlin.reflect.KProperty]`<* | `[`DataRow`][org.jetbrains.kotlinx.dataframe.DataRow]`<*>> | `[`ColumnPath`][org.jetbrains.kotlinx.dataframe.columns.ColumnPath]
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  `column: `[`ColumnAccessor`][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor]`  |  `[`String`][String]`  | `[`KProperty`][kotlin.reflect.KProperty]`<*> | `[`ColumnPath`][org.jetbrains.kotlinx.dataframe.columns.ColumnPath]
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  `index: `[`Int`][Int]
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  `T: Column type`
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  ### What can be called directly in the [Columns Selection DSL][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl]:
+     *
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  [**`frameCol`**][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.frameCol]`[`**`<`**[`T`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ColumnTypeDef]**`>`**`]`**`(`**[`column`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ColumnDef]`  |  `[`index`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.IndexDef]**`)`**
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  ### What can be called on a [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]:
+     *
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  [`columnSet`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ColumnSetDef]
+     *
+     *  &nbsp;&nbsp;&nbsp;&nbsp;__`.`__[**`frameCol`**][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.frameCol]**`(`**[`index`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.IndexDef]**`)`**
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  ### What can be called on a [Column Group (reference)][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ColumnGroupDef]:
+     *
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  [`columnGroup`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ColumnGroupDef]
+     *
+     *  &nbsp;&nbsp;&nbsp;&nbsp;__`.`__[**`frameCol`**][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.frameCol]`[`**`<`**[`T`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ColumnTypeDef]**`>`**`]`**`(`**[`column`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ColumnDef]`  |  `[`index`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.IndexDef]**`)`**
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     */
+    public interface Grammar {
+
+        /** [**`frameCol`**][ColumnsSelectionDsl.frameCol] */
+        public interface PlainDslName
+
+        /** __`.`__[**`frameCol`**][ColumnsSelectionDsl.frameCol] */
+        public interface ColumnSetName
+
+        /** __`.`__[**`frameCol`**][ColumnsSelectionDsl.frameCol] */
+        public interface ColumnGroupName
+    }
+
+    /**
+     * ## Frame Col
+     *
+     * Creates a [ColumnAccessor] (or [SingleColumn]) for a frame column with the given argument which can be either
+     * an index ([Int]) or a reference to a column
+     * ([String], [ColumnPath], [KProperty], or [ColumnAccessor]; any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+     *
+     * This is a DSL-shorthand for [frameColumn] and can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index). In addition, extra runtime checks are in place to ensure that the column
+     * you specify is actually a frame column.
+     * The function can also be called on [ColumnGroups][ColumnGroupReference] to create
+     * an accessor for a frame column inside a [ColumnGroup].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     *
+     * ### Check out: [Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][DataFrame.select]`  {  `[frameCol][frameCol]`<`[String][String]`>("frameColA") }`
+     *
+     * `df.`[select][DataFrame.select]`  {  `[frameCol][frameCol]`(SomeType::frameColB) }`
+     *
+     * `df.`[select][DataFrame.select]` { myColumnGroup.`[frameCol][frameCol]`(1) }`
+     *
+     * #### Examples for this overload:
+     *
+     *
+     *
+     * To create a [ColumnAccessor] for another kind of column, take a look at the functions
+     * [col][ColumnsSelectionDsl.col],
+     * [colGroup][ColumnsSelectionDsl.colGroup],
+     * and [valueCol][ColumnsSelectionDsl.valueCol].
+     *
+     * @return A [ColumnAccessor] for the frame column with the given argument if possible, else a [SingleColumn].
+     * @throws [IllegalStateException] if the column with the given argument does not exist.
+     * @throws [IllegalArgumentException] if the column with the given argument is not a frame column.
+     *
+     * @see [frameColumn]
+     * @see [ColumnsSelectionDsl.colGroup]
+     * @see [ColumnsSelectionDsl.valueCol]
+     * @see [ColumnsSelectionDsl.col]
+     *
+     */
+    private interface CommonFrameColDocs {
+
+        // Example argument, can be either {@include [SingleExample]} or {@include [DoubleExample]}
+        interface ExampleArg
+
+        /**
+         * `df.`[select][DataFrame.select]` { `[frameCol][frameCol]`() }`
+         */
+        interface SingleExample
+
+        /**
+         * `df.`[select][DataFrame.select]` { `[frameCol][frameCol]`() }`
+         *
+         * `df.`[select][DataFrame.select]` { `[frameCol][frameCol]`<`[String][String]`>() }`
+         */
+        interface DoubleExample
+
+        // Receiver argument for the example(s)
+        interface ReceiverArg
+
+        // Argument for the example(s)
+        interface Arg
+
+        // Optional note
+        interface Note
+
+        /** @param [C] The type of the frame column. */
+        interface FrameColumnTypeParam
+    }
+
+    // region reference
+
+    /**
+     * ## Frame Col
+     *
+     * Creates a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] (or [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]) for a frame column with the given argument which can be either
+     * an index ([Int]) or a reference to a column
+     * ([String], [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath], [KProperty], or [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor]; any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+     *
+     * This is a DSL-shorthand for [frameColumn][org.jetbrains.kotlinx.dataframe.api.frameColumn] and can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index). In addition, extra runtime checks are in place to ensure that the column
+     * you specify is actually a frame column.
+     * The function can also be called on [ColumnGroups][org.jetbrains.kotlinx.dataframe.ColumnGroupReference] to create
+     * an accessor for a frame column inside a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`<`[String][String]`>("frameColA") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`(SomeType::frameColB) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`(1) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { `[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`(frameColumnA) }`
+     *
+     * To create a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for another kind of column, take a look at the functions
+     * [col][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.col],
+     * [colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup],
+     * and [valueCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.valueCol].
+     *
+     * @return A [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for the frame column with the given argument if possible, else a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn].
+     * @throws [IllegalStateException] if the column with the given argument does not exist.
+     * @throws [IllegalArgumentException] if the column with the given argument is not a frame column.
+     *
+     * @see [frameColumn]
+     * @see [ColumnsSelectionDsl.colGroup]
+     * @see [ColumnsSelectionDsl.valueCol]
+     * @see [ColumnsSelectionDsl.col]
+     *
+     *
+     *
+     * @param [col] The [ColumnAccessor] pointing to the value column.
+     * @param [C] The type of the frame column.
+     */
+    private interface FrameColReferenceDocs
+
+    /**
+     * ## Frame Col
+     *
+     * Creates a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] (or [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]) for a frame column with the given argument which can be either
+     * an index ([Int]) or a reference to a column
+     * ([String], [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath], [KProperty], or [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor]; any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+     *
+     * This is a DSL-shorthand for [frameColumn][org.jetbrains.kotlinx.dataframe.api.frameColumn] and can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index). In addition, extra runtime checks are in place to ensure that the column
+     * you specify is actually a frame column.
+     * The function can also be called on [ColumnGroups][org.jetbrains.kotlinx.dataframe.ColumnGroupReference] to create
+     * an accessor for a frame column inside a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`<`[String][String]`>("frameColA") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`(SomeType::frameColB) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`(1) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { `[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`(frameColumnA) }`
+     *
+     * To create a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for another kind of column, take a look at the functions
+     * [col][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.col],
+     * [colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup],
+     * and [valueCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.valueCol].
+     *
+     * @return A [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for the frame column with the given argument if possible, else a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn].
+     * @throws [IllegalStateException] if the column with the given argument does not exist.
+     * @throws [IllegalArgumentException] if the column with the given argument is not a frame column.
+     *
+     * @see [frameColumn]
+     * @see [ColumnsSelectionDsl.colGroup]
+     * @see [ColumnsSelectionDsl.valueCol]
+     * @see [ColumnsSelectionDsl.col]
+     *
+     *
+     *
+     * @param [col] The [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] pointing to the value column.
+     * @param [C] The type of the frame column.
+     */
+    public fun <C> frameCol(frameCol: ColumnAccessor<DataFrame<C>>): ColumnAccessor<DataFrame<C>> =
+        frameCol.ensureIsFrameColumn()
+
+    /**
+     * ## Frame Col
+     *
+     * Creates a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] (or [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]) for a frame column with the given argument which can be either
+     * an index ([Int]) or a reference to a column
+     * ([String], [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath], [KProperty], or [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor]; any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+     *
+     * This is a DSL-shorthand for [frameColumn][org.jetbrains.kotlinx.dataframe.api.frameColumn] and can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index). In addition, extra runtime checks are in place to ensure that the column
+     * you specify is actually a frame column.
+     * The function can also be called on [ColumnGroups][org.jetbrains.kotlinx.dataframe.ColumnGroupReference] to create
+     * an accessor for a frame column inside a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`<`[String][String]`>("frameColA") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`(SomeType::frameColB) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`(1) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`(frameColumnA) }`
+     *
+     * To create a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for another kind of column, take a look at the functions
+     * [col][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.col],
+     * [colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup],
+     * and [valueCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.valueCol].
+     *
+     * @return A [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for the frame column with the given argument if possible, else a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn].
+     * @throws [IllegalStateException] if the column with the given argument does not exist.
+     * @throws [IllegalArgumentException] if the column with the given argument is not a frame column.
+     *
+     * @see [frameColumn]
+     * @see [ColumnsSelectionDsl.colGroup]
+     * @see [ColumnsSelectionDsl.valueCol]
+     * @see [ColumnsSelectionDsl.col]
+     *
+     *
+     *
+     * @param [col] The [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] pointing to the value column.
+     * @param [C] The type of the frame column.
+     */
+    public fun <C> SingleColumn<DataRow<*>>.frameCol(
+        frameCol: ColumnAccessor<DataFrame<C>>,
+    ): SingleColumn<DataFrame<C>> =
+        this.ensureIsColumnGroup().transformSingle {
+            val child = it.getCol(frameCol)
+                ?: throw IllegalStateException(
+                    "FrameColumn '${frameCol.path()}' not found in column group '${it.path}'",
+                )
+            child.data.ensureIsFrameColumn()
+            listOf(child)
+        }.singleImpl()
+
+    /**
+     * ## Frame Col
+     *
+     * Creates a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] (or [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]) for a frame column with the given argument which can be either
+     * an index ([Int]) or a reference to a column
+     * ([String], [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath], [KProperty], or [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor]; any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+     *
+     * This is a DSL-shorthand for [frameColumn][org.jetbrains.kotlinx.dataframe.api.frameColumn] and can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index). In addition, extra runtime checks are in place to ensure that the column
+     * you specify is actually a frame column.
+     * The function can also be called on [ColumnGroups][org.jetbrains.kotlinx.dataframe.ColumnGroupReference] to create
+     * an accessor for a frame column inside a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`<`[String][String]`>("frameColA") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`(SomeType::frameColB) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`(1) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`(frameColumnA) }`
+     *
+     * To create a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for another kind of column, take a look at the functions
+     * [col][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.col],
+     * [colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup],
+     * and [valueCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.valueCol].
+     *
+     * @return A [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for the frame column with the given argument if possible, else a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn].
+     * @throws [IllegalStateException] if the column with the given argument does not exist.
+     * @throws [IllegalArgumentException] if the column with the given argument is not a frame column.
+     *
+     * @see [frameColumn]
+     * @see [ColumnsSelectionDsl.colGroup]
+     * @see [ColumnsSelectionDsl.valueCol]
+     * @see [ColumnsSelectionDsl.col]
+     *
+     *
+     *
+     * @param [col] The [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] pointing to the value column.
+     * @param [C] The type of the frame column.
+     */
+    public fun <C> AnyColumnGroupAccessor.frameCol(
+        frameCol: ColumnAccessor<DataFrame<C>>,
+    ): ColumnAccessor<DataFrame<C>> = this.ensureIsColumnGroup().frameColumn<C>(frameCol.path()).ensureIsFrameColumn()
+
+    /**
+     * ## Frame Col
+     *
+     * Creates a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] (or [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]) for a frame column with the given argument which can be either
+     * an index ([Int]) or a reference to a column
+     * ([String], [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath], [KProperty], or [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor]; any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+     *
+     * This is a DSL-shorthand for [frameColumn][org.jetbrains.kotlinx.dataframe.api.frameColumn] and can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index). In addition, extra runtime checks are in place to ensure that the column
+     * you specify is actually a frame column.
+     * The function can also be called on [ColumnGroups][org.jetbrains.kotlinx.dataframe.ColumnGroupReference] to create
+     * an accessor for a frame column inside a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`<`[String][String]`>("frameColA") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`(SomeType::frameColB) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`(1) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "myColumnGroup".`[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`(frameColumnA) }`
+     *
+     * To create a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for another kind of column, take a look at the functions
+     * [col][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.col],
+     * [colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup],
+     * and [valueCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.valueCol].
+     *
+     * @return A [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for the frame column with the given argument if possible, else a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn].
+     * @throws [IllegalStateException] if the column with the given argument does not exist.
+     * @throws [IllegalArgumentException] if the column with the given argument is not a frame column.
+     *
+     * @see [frameColumn]
+     * @see [ColumnsSelectionDsl.colGroup]
+     * @see [ColumnsSelectionDsl.valueCol]
+     * @see [ColumnsSelectionDsl.col]
+     *
+     *
+     *
+     * @param [col] The [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] pointing to the value column.
+     * @param [C] The type of the frame column.
+     */
+    public fun <C> String.frameCol(frameCol: ColumnAccessor<DataFrame<C>>): ColumnAccessor<DataFrame<C>> =
+        columnGroup(this).ensureIsColumnGroup().frameColumn<C>(frameCol.path()).ensureIsFrameColumn()
+
+    /**
+     * ## Frame Col
+     *
+     * Creates a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] (or [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]) for a frame column with the given argument which can be either
+     * an index ([Int]) or a reference to a column
+     * ([String], [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath], [KProperty], or [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor]; any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+     *
+     * This is a DSL-shorthand for [frameColumn][org.jetbrains.kotlinx.dataframe.api.frameColumn] and can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index). In addition, extra runtime checks are in place to ensure that the column
+     * you specify is actually a frame column.
+     * The function can also be called on [ColumnGroups][org.jetbrains.kotlinx.dataframe.ColumnGroupReference] to create
+     * an accessor for a frame column inside a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`<`[String][String]`>("frameColA") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`(SomeType::frameColB) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`(1) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { Type::myColumnGroup.`[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`(frameColumnA) }`
+     *
+     * To create a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for another kind of column, take a look at the functions
+     * [col][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.col],
+     * [colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup],
+     * and [valueCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.valueCol].
+     *
+     * @return A [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for the frame column with the given argument if possible, else a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn].
+     * @throws [IllegalStateException] if the column with the given argument does not exist.
+     * @throws [IllegalArgumentException] if the column with the given argument is not a frame column.
+     *
+     * @see [frameColumn]
+     * @see [ColumnsSelectionDsl.colGroup]
+     * @see [ColumnsSelectionDsl.valueCol]
+     * @see [ColumnsSelectionDsl.col]
+     *
+     *
+     *
+     * @param [col] The [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] pointing to the value column.
+     * @param [C] The type of the frame column.
+     */
+    public fun <C> KProperty<*>.frameCol(frameCol: ColumnAccessor<DataFrame<C>>): ColumnAccessor<DataFrame<C>> =
+        columnGroup(this).ensureIsColumnGroup().frameColumn<C>(frameCol.path()).ensureIsFrameColumn()
+
+    /**
+     * ## Frame Col
+     *
+     * Creates a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] (or [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]) for a frame column with the given argument which can be either
+     * an index ([Int]) or a reference to a column
+     * ([String], [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath], [KProperty], or [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor]; any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+     *
+     * This is a DSL-shorthand for [frameColumn][org.jetbrains.kotlinx.dataframe.api.frameColumn] and can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index). In addition, extra runtime checks are in place to ensure that the column
+     * you specify is actually a frame column.
+     * The function can also be called on [ColumnGroups][org.jetbrains.kotlinx.dataframe.ColumnGroupReference] to create
+     * an accessor for a frame column inside a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`<`[String][String]`>("frameColA") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`(SomeType::frameColB) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`(1) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "pathTo"["myColumnGroup"].`[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`(frameColumnA) }`
+     *
+     * To create a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for another kind of column, take a look at the functions
+     * [col][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.col],
+     * [colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup],
+     * and [valueCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.valueCol].
+     *
+     * @return A [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for the frame column with the given argument if possible, else a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn].
+     * @throws [IllegalStateException] if the column with the given argument does not exist.
+     * @throws [IllegalArgumentException] if the column with the given argument is not a frame column.
+     *
+     * @see [frameColumn]
+     * @see [ColumnsSelectionDsl.colGroup]
+     * @see [ColumnsSelectionDsl.valueCol]
+     * @see [ColumnsSelectionDsl.col]
+     *
+     *
+     *
+     * @param [col] The [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] pointing to the value column.
+     * @param [C] The type of the frame column.
+     */
+    public fun <C> ColumnPath.frameCol(frameCol: ColumnAccessor<DataFrame<C>>): ColumnAccessor<DataFrame<C>> =
+        columnGroup(this).ensureIsColumnGroup().frameColumn<C>(frameCol.path()).ensureIsFrameColumn()
+
+    // endregion
+
+    // region name
+
+    /**
+     * ## Frame Col
+     *
+     * Creates a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] (or [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]) for a frame column with the given argument which can be either
+     * an index ([Int]) or a reference to a column
+     * ([String], [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath], [KProperty], or [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor]; any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+     *
+     * This is a DSL-shorthand for [frameColumn][org.jetbrains.kotlinx.dataframe.api.frameColumn] and can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index). In addition, extra runtime checks are in place to ensure that the column
+     * you specify is actually a frame column.
+     * The function can also be called on [ColumnGroups][org.jetbrains.kotlinx.dataframe.ColumnGroupReference] to create
+     * an accessor for a frame column inside a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`<`[String][String]`>("frameColA") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`(SomeType::frameColB) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`(1) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { `[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`("frameColumnName") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { `[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`<`[String][String]`>("frameColumnName") }`
+     *
+     * To create a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for another kind of column, take a look at the functions
+     * [col][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.col],
+     * [colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup],
+     * and [valueCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.valueCol].
+     *
+     * @return A [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for the frame column with the given argument if possible, else a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn].
+     * @throws [IllegalStateException] if the column with the given argument does not exist.
+     * @throws [IllegalArgumentException] if the column with the given argument is not a frame column.
+     *
+     * @see [frameColumn]
+     * @see [ColumnsSelectionDsl.colGroup]
+     * @see [ColumnsSelectionDsl.valueCol]
+     * @see [ColumnsSelectionDsl.col]
+     *
+     *
+     *
+     * @param [name] The name of the value column.
+     */
+    private interface FrameColNameDocs
+
+    /**
+     * ## Frame Col
+     *
+     * Creates a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] (or [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]) for a frame column with the given argument which can be either
+     * an index ([Int]) or a reference to a column
+     * ([String], [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath], [KProperty], or [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor]; any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+     *
+     * This is a DSL-shorthand for [frameColumn][org.jetbrains.kotlinx.dataframe.api.frameColumn] and can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index). In addition, extra runtime checks are in place to ensure that the column
+     * you specify is actually a frame column.
+     * The function can also be called on [ColumnGroups][org.jetbrains.kotlinx.dataframe.ColumnGroupReference] to create
+     * an accessor for a frame column inside a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`<`[String][String]`>("frameColA") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`(SomeType::frameColB) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`(1) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { `[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`("frameColumnName") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { `[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`<`[String][String]`>("frameColumnName") }`
+     *
+     * To create a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for another kind of column, take a look at the functions
+     * [col][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.col],
+     * [colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup],
+     * and [valueCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.valueCol].
+     *
+     * @return A [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for the frame column with the given argument if possible, else a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn].
+     * @throws [IllegalStateException] if the column with the given argument does not exist.
+     * @throws [IllegalArgumentException] if the column with the given argument is not a frame column.
+     *
+     * @see [frameColumn]
+     * @see [ColumnsSelectionDsl.colGroup]
+     * @see [ColumnsSelectionDsl.valueCol]
+     * @see [ColumnsSelectionDsl.col]
+     *
+     *
+     *
+     * @param [name] The name of the value column.
+     */
+    @Suppress("INAPPLICABLE_JVM_NAME")
+    @JvmName("frameColUnTyped")
+    public fun frameCol(name: String): ColumnAccessor<DataFrame<*>> = frameColumn<Any?>(name).ensureIsFrameColumn()
+
+    /**
+     * ## Frame Col
+     *
+     * Creates a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] (or [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]) for a frame column with the given argument which can be either
+     * an index ([Int]) or a reference to a column
+     * ([String], [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath], [KProperty], or [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor]; any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+     *
+     * This is a DSL-shorthand for [frameColumn][org.jetbrains.kotlinx.dataframe.api.frameColumn] and can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index). In addition, extra runtime checks are in place to ensure that the column
+     * you specify is actually a frame column.
+     * The function can also be called on [ColumnGroups][org.jetbrains.kotlinx.dataframe.ColumnGroupReference] to create
+     * an accessor for a frame column inside a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`<`[String][String]`>("frameColA") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`(SomeType::frameColB) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`(1) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { `[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`("frameColumnName") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { `[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`<`[String][String]`>("frameColumnName") }`
+     *
+     * To create a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for another kind of column, take a look at the functions
+     * [col][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.col],
+     * [colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup],
+     * and [valueCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.valueCol].
+     *
+     * @return A [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for the frame column with the given argument if possible, else a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn].
+     * @throws [IllegalStateException] if the column with the given argument does not exist.
+     * @throws [IllegalArgumentException] if the column with the given argument is not a frame column.
+     *
+     * @see [frameColumn]
+     * @see [ColumnsSelectionDsl.colGroup]
+     * @see [ColumnsSelectionDsl.valueCol]
+     * @see [ColumnsSelectionDsl.col]
+     *
+     *
+     *
+     * @param [name] The name of the value column.
+     * @param [C] The type of the frame column.
+     */
+    public fun <C> frameCol(name: String): ColumnAccessor<DataFrame<C>> = frameColumn<C>(name).ensureIsFrameColumn()
+
+    /**
+     * ## Frame Col
+     *
+     * Creates a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] (or [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]) for a frame column with the given argument which can be either
+     * an index ([Int]) or a reference to a column
+     * ([String], [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath], [KProperty], or [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor]; any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+     *
+     * This is a DSL-shorthand for [frameColumn][org.jetbrains.kotlinx.dataframe.api.frameColumn] and can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index). In addition, extra runtime checks are in place to ensure that the column
+     * you specify is actually a frame column.
+     * The function can also be called on [ColumnGroups][org.jetbrains.kotlinx.dataframe.ColumnGroupReference] to create
+     * an accessor for a frame column inside a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`<`[String][String]`>("frameColA") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`(SomeType::frameColB) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`(1) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`("frameColumnName") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`<`[String][String]`>("frameColumnName") }`
+     *
+     * To create a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for another kind of column, take a look at the functions
+     * [col][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.col],
+     * [colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup],
+     * and [valueCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.valueCol].
+     *
+     * @return A [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for the frame column with the given argument if possible, else a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn].
+     * @throws [IllegalStateException] if the column with the given argument does not exist.
+     * @throws [IllegalArgumentException] if the column with the given argument is not a frame column.
+     *
+     * @see [frameColumn]
+     * @see [ColumnsSelectionDsl.colGroup]
+     * @see [ColumnsSelectionDsl.valueCol]
+     * @see [ColumnsSelectionDsl.col]
+     *
+     *
+     *
+     * @param [name] The name of the value column.
+     */
+    @Suppress("INAPPLICABLE_JVM_NAME")
+    @JvmName("frameColUnTyped")
+    public fun SingleColumn<DataRow<*>>.frameCol(name: String): SingleColumn<DataFrame<*>> = frameCol<Any?>(name)
+
+    /**
+     * ## Frame Col
+     *
+     * Creates a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] (or [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]) for a frame column with the given argument which can be either
+     * an index ([Int]) or a reference to a column
+     * ([String], [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath], [KProperty], or [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor]; any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+     *
+     * This is a DSL-shorthand for [frameColumn][org.jetbrains.kotlinx.dataframe.api.frameColumn] and can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index). In addition, extra runtime checks are in place to ensure that the column
+     * you specify is actually a frame column.
+     * The function can also be called on [ColumnGroups][org.jetbrains.kotlinx.dataframe.ColumnGroupReference] to create
+     * an accessor for a frame column inside a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`<`[String][String]`>("frameColA") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`(SomeType::frameColB) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`(1) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`("frameColumnName") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`<`[String][String]`>("frameColumnName") }`
+     *
+     * To create a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for another kind of column, take a look at the functions
+     * [col][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.col],
+     * [colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup],
+     * and [valueCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.valueCol].
+     *
+     * @return A [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for the frame column with the given argument if possible, else a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn].
+     * @throws [IllegalStateException] if the column with the given argument does not exist.
+     * @throws [IllegalArgumentException] if the column with the given argument is not a frame column.
+     *
+     * @see [frameColumn]
+     * @see [ColumnsSelectionDsl.colGroup]
+     * @see [ColumnsSelectionDsl.valueCol]
+     * @see [ColumnsSelectionDsl.col]
+     *
+     *
+     *
+     * @param [name] The name of the value column.
+     * @param [C] The type of the frame column.
+     */
+    public fun <C> SingleColumn<DataRow<*>>.frameCol(name: String): SingleColumn<DataFrame<C>> =
+        this.ensureIsColumnGroup().transformSingle {
+            val child = it.getCol(name)?.cast<DataFrame<C>>()
+                ?: throw IllegalStateException("Frame column '$name' not found in column group '${it.path}'")
+            child.data.ensureIsFrameColumn()
+            listOf(child)
+        }.singleImpl()
+
+    /**
+     * ## Frame Col
+     *
+     * Creates a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] (or [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]) for a frame column with the given argument which can be either
+     * an index ([Int]) or a reference to a column
+     * ([String], [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath], [KProperty], or [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor]; any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+     *
+     * This is a DSL-shorthand for [frameColumn][org.jetbrains.kotlinx.dataframe.api.frameColumn] and can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index). In addition, extra runtime checks are in place to ensure that the column
+     * you specify is actually a frame column.
+     * The function can also be called on [ColumnGroups][org.jetbrains.kotlinx.dataframe.ColumnGroupReference] to create
+     * an accessor for a frame column inside a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`<`[String][String]`>("frameColA") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`(SomeType::frameColB) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`(1) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`("frameColumnName") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`<`[String][String]`>("frameColumnName") }`
+     *
+     * To create a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for another kind of column, take a look at the functions
+     * [col][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.col],
+     * [colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup],
+     * and [valueCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.valueCol].
+     *
+     * @return A [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for the frame column with the given argument if possible, else a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn].
+     * @throws [IllegalStateException] if the column with the given argument does not exist.
+     * @throws [IllegalArgumentException] if the column with the given argument is not a frame column.
+     *
+     * @see [frameColumn]
+     * @see [ColumnsSelectionDsl.colGroup]
+     * @see [ColumnsSelectionDsl.valueCol]
+     * @see [ColumnsSelectionDsl.col]
+     *
+     *
+     *
+     * @param [name] The name of the value column.
+     */
+    @Suppress("INAPPLICABLE_JVM_NAME")
+    @JvmName("frameColUnTyped")
+    public fun AnyColumnGroupAccessor.frameCol(name: String): ColumnAccessor<DataFrame<*>> = frameCol<Any?>(name)
+
+    /**
+     * ## Frame Col
+     *
+     * Creates a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] (or [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]) for a frame column with the given argument which can be either
+     * an index ([Int]) or a reference to a column
+     * ([String], [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath], [KProperty], or [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor]; any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+     *
+     * This is a DSL-shorthand for [frameColumn][org.jetbrains.kotlinx.dataframe.api.frameColumn] and can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index). In addition, extra runtime checks are in place to ensure that the column
+     * you specify is actually a frame column.
+     * The function can also be called on [ColumnGroups][org.jetbrains.kotlinx.dataframe.ColumnGroupReference] to create
+     * an accessor for a frame column inside a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`<`[String][String]`>("frameColA") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`(SomeType::frameColB) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`(1) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`("frameColumnName") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`<`[String][String]`>("frameColumnName") }`
+     *
+     * To create a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for another kind of column, take a look at the functions
+     * [col][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.col],
+     * [colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup],
+     * and [valueCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.valueCol].
+     *
+     * @return A [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for the frame column with the given argument if possible, else a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn].
+     * @throws [IllegalStateException] if the column with the given argument does not exist.
+     * @throws [IllegalArgumentException] if the column with the given argument is not a frame column.
+     *
+     * @see [frameColumn]
+     * @see [ColumnsSelectionDsl.colGroup]
+     * @see [ColumnsSelectionDsl.valueCol]
+     * @see [ColumnsSelectionDsl.col]
+     *
+     *
+     *
+     * @param [name] The name of the value column.
+     * @param [C] The type of the frame column.
+     */
+    public fun <C> AnyColumnGroupAccessor.frameCol(name: String): ColumnAccessor<DataFrame<C>> =
+        this.ensureIsColumnGroup().frameColumn<C>(name).ensureIsFrameColumn()
+
+    /**
+     * ## Frame Col
+     *
+     * Creates a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] (or [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]) for a frame column with the given argument which can be either
+     * an index ([Int]) or a reference to a column
+     * ([String], [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath], [KProperty], or [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor]; any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+     *
+     * This is a DSL-shorthand for [frameColumn][org.jetbrains.kotlinx.dataframe.api.frameColumn] and can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index). In addition, extra runtime checks are in place to ensure that the column
+     * you specify is actually a frame column.
+     * The function can also be called on [ColumnGroups][org.jetbrains.kotlinx.dataframe.ColumnGroupReference] to create
+     * an accessor for a frame column inside a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`<`[String][String]`>("frameColA") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`(SomeType::frameColB) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`(1) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "myColumnGroup".`[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`("frameColumnName") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "myColumnGroup".`[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`<`[String][String]`>("frameColumnName") }`
+     *
+     * To create a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for another kind of column, take a look at the functions
+     * [col][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.col],
+     * [colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup],
+     * and [valueCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.valueCol].
+     *
+     * @return A [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for the frame column with the given argument if possible, else a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn].
+     * @throws [IllegalStateException] if the column with the given argument does not exist.
+     * @throws [IllegalArgumentException] if the column with the given argument is not a frame column.
+     *
+     * @see [frameColumn]
+     * @see [ColumnsSelectionDsl.colGroup]
+     * @see [ColumnsSelectionDsl.valueCol]
+     * @see [ColumnsSelectionDsl.col]
+     *
+     *
+     *
+     * @param [name] The name of the value column.
+     */
+    @Suppress("INAPPLICABLE_JVM_NAME")
+    @JvmName("frameColUnTyped")
+    public fun String.frameCol(name: String): ColumnAccessor<DataFrame<*>> = frameCol<Any?>(name)
+
+    /**
+     * ## Frame Col
+     *
+     * Creates a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] (or [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]) for a frame column with the given argument which can be either
+     * an index ([Int]) or a reference to a column
+     * ([String], [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath], [KProperty], or [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor]; any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+     *
+     * This is a DSL-shorthand for [frameColumn][org.jetbrains.kotlinx.dataframe.api.frameColumn] and can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index). In addition, extra runtime checks are in place to ensure that the column
+     * you specify is actually a frame column.
+     * The function can also be called on [ColumnGroups][org.jetbrains.kotlinx.dataframe.ColumnGroupReference] to create
+     * an accessor for a frame column inside a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`<`[String][String]`>("frameColA") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`(SomeType::frameColB) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`(1) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "myColumnGroup".`[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`("frameColumnName") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "myColumnGroup".`[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`<`[String][String]`>("frameColumnName") }`
+     *
+     * To create a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for another kind of column, take a look at the functions
+     * [col][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.col],
+     * [colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup],
+     * and [valueCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.valueCol].
+     *
+     * @return A [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for the frame column with the given argument if possible, else a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn].
+     * @throws [IllegalStateException] if the column with the given argument does not exist.
+     * @throws [IllegalArgumentException] if the column with the given argument is not a frame column.
+     *
+     * @see [frameColumn]
+     * @see [ColumnsSelectionDsl.colGroup]
+     * @see [ColumnsSelectionDsl.valueCol]
+     * @see [ColumnsSelectionDsl.col]
+     *
+     *
+     *
+     * @param [name] The name of the value column.
+     * @param [C] The type of the frame column.
+     */
+    public fun <C> String.frameCol(name: String): ColumnAccessor<DataFrame<C>> =
+        columnGroup(this).ensureIsColumnGroup().frameColumn<C>(name).ensureIsFrameColumn()
+
+    /**
+     * ## Frame Col
+     *
+     * Creates a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] (or [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]) for a frame column with the given argument which can be either
+     * an index ([Int]) or a reference to a column
+     * ([String], [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath], [KProperty], or [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor]; any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+     *
+     * This is a DSL-shorthand for [frameColumn][org.jetbrains.kotlinx.dataframe.api.frameColumn] and can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index). In addition, extra runtime checks are in place to ensure that the column
+     * you specify is actually a frame column.
+     * The function can also be called on [ColumnGroups][org.jetbrains.kotlinx.dataframe.ColumnGroupReference] to create
+     * an accessor for a frame column inside a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`<`[String][String]`>("frameColA") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`(SomeType::frameColB) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`(1) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { Type::myColumnGroup.`[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`("frameColumnName") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { Type::myColumnGroup.`[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`<`[String][String]`>("frameColumnName") }`
+     *
+     * To create a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for another kind of column, take a look at the functions
+     * [col][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.col],
+     * [colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup],
+     * and [valueCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.valueCol].
+     *
+     * @return A [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for the frame column with the given argument if possible, else a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn].
+     * @throws [IllegalStateException] if the column with the given argument does not exist.
+     * @throws [IllegalArgumentException] if the column with the given argument is not a frame column.
+     *
+     * @see [frameColumn]
+     * @see [ColumnsSelectionDsl.colGroup]
+     * @see [ColumnsSelectionDsl.valueCol]
+     * @see [ColumnsSelectionDsl.col]
+     *
+     *
+     *
+     * @param [name] The name of the value column.
+     */
+    @Suppress("INAPPLICABLE_JVM_NAME")
+    @JvmName("frameColUnTyped")
+    public fun KProperty<*>.frameCol(name: String): ColumnAccessor<DataFrame<*>> = frameCol<Any?>(name)
+
+    /**
+     * ## Frame Col
+     *
+     * Creates a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] (or [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]) for a frame column with the given argument which can be either
+     * an index ([Int]) or a reference to a column
+     * ([String], [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath], [KProperty], or [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor]; any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+     *
+     * This is a DSL-shorthand for [frameColumn][org.jetbrains.kotlinx.dataframe.api.frameColumn] and can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index). In addition, extra runtime checks are in place to ensure that the column
+     * you specify is actually a frame column.
+     * The function can also be called on [ColumnGroups][org.jetbrains.kotlinx.dataframe.ColumnGroupReference] to create
+     * an accessor for a frame column inside a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`<`[String][String]`>("frameColA") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`(SomeType::frameColB) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`(1) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { Type::myColumnGroup.`[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`("frameColumnName") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { Type::myColumnGroup.`[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`<`[String][String]`>("frameColumnName") }`
+     *
+     * To create a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for another kind of column, take a look at the functions
+     * [col][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.col],
+     * [colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup],
+     * and [valueCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.valueCol].
+     *
+     * @return A [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for the frame column with the given argument if possible, else a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn].
+     * @throws [IllegalStateException] if the column with the given argument does not exist.
+     * @throws [IllegalArgumentException] if the column with the given argument is not a frame column.
+     *
+     * @see [frameColumn]
+     * @see [ColumnsSelectionDsl.colGroup]
+     * @see [ColumnsSelectionDsl.valueCol]
+     * @see [ColumnsSelectionDsl.col]
+     *
+     *
+     *
+     * @param [name] The name of the value column.
+     * @param [C] The type of the frame column.
+     */
+    public fun <C> KProperty<*>.frameCol(name: String): ColumnAccessor<DataFrame<C>> =
+        columnGroup(this).ensureIsColumnGroup().frameColumn<C>(name).ensureIsFrameColumn()
+
+    /**
+     * ## Frame Col
+     *
+     * Creates a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] (or [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]) for a frame column with the given argument which can be either
+     * an index ([Int]) or a reference to a column
+     * ([String], [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath], [KProperty], or [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor]; any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+     *
+     * This is a DSL-shorthand for [frameColumn][org.jetbrains.kotlinx.dataframe.api.frameColumn] and can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index). In addition, extra runtime checks are in place to ensure that the column
+     * you specify is actually a frame column.
+     * The function can also be called on [ColumnGroups][org.jetbrains.kotlinx.dataframe.ColumnGroupReference] to create
+     * an accessor for a frame column inside a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`<`[String][String]`>("frameColA") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`(SomeType::frameColB) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`(1) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "pathTo"["myColumnGroup"].`[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`("frameColumnName") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "pathTo"["myColumnGroup"].`[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`<`[String][String]`>("frameColumnName") }`
+     *
+     * To create a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for another kind of column, take a look at the functions
+     * [col][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.col],
+     * [colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup],
+     * and [valueCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.valueCol].
+     *
+     * @return A [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for the frame column with the given argument if possible, else a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn].
+     * @throws [IllegalStateException] if the column with the given argument does not exist.
+     * @throws [IllegalArgumentException] if the column with the given argument is not a frame column.
+     *
+     * @see [frameColumn]
+     * @see [ColumnsSelectionDsl.colGroup]
+     * @see [ColumnsSelectionDsl.valueCol]
+     * @see [ColumnsSelectionDsl.col]
+     *
+     *
+     *
+     * @param [name] The name of the value column.
+     */
+    @Suppress("INAPPLICABLE_JVM_NAME")
+    @JvmName("frameColUnTyped")
+    public fun ColumnPath.frameCol(name: String): ColumnAccessor<DataFrame<*>> = frameCol<Any?>(name)
+
+    /**
+     * ## Frame Col
+     *
+     * Creates a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] (or [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]) for a frame column with the given argument which can be either
+     * an index ([Int]) or a reference to a column
+     * ([String], [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath], [KProperty], or [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor]; any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+     *
+     * This is a DSL-shorthand for [frameColumn][org.jetbrains.kotlinx.dataframe.api.frameColumn] and can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index). In addition, extra runtime checks are in place to ensure that the column
+     * you specify is actually a frame column.
+     * The function can also be called on [ColumnGroups][org.jetbrains.kotlinx.dataframe.ColumnGroupReference] to create
+     * an accessor for a frame column inside a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`<`[String][String]`>("frameColA") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`(SomeType::frameColB) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`(1) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "pathTo"["myColumnGroup"].`[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`("frameColumnName") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "pathTo"["myColumnGroup"].`[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`<`[String][String]`>("frameColumnName") }`
+     *
+     * To create a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for another kind of column, take a look at the functions
+     * [col][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.col],
+     * [colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup],
+     * and [valueCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.valueCol].
+     *
+     * @return A [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for the frame column with the given argument if possible, else a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn].
+     * @throws [IllegalStateException] if the column with the given argument does not exist.
+     * @throws [IllegalArgumentException] if the column with the given argument is not a frame column.
+     *
+     * @see [frameColumn]
+     * @see [ColumnsSelectionDsl.colGroup]
+     * @see [ColumnsSelectionDsl.valueCol]
+     * @see [ColumnsSelectionDsl.col]
+     *
+     *
+     *
+     * @param [name] The name of the value column.
+     * @param [C] The type of the frame column.
+     */
+    public fun <C> ColumnPath.frameCol(name: String): ColumnAccessor<DataFrame<C>> =
+        columnGroup(this).ensureIsColumnGroup().frameColumn<C>(name).ensureIsFrameColumn()
+
+    // endregion
+
+    // region path
+
+    /**
+     * ## Frame Col
+     *
+     * Creates a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] (or [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]) for a frame column with the given argument which can be either
+     * an index ([Int]) or a reference to a column
+     * ([String], [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath], [KProperty], or [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor]; any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+     *
+     * This is a DSL-shorthand for [frameColumn][org.jetbrains.kotlinx.dataframe.api.frameColumn] and can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index). In addition, extra runtime checks are in place to ensure that the column
+     * you specify is actually a frame column.
+     * The function can also be called on [ColumnGroups][org.jetbrains.kotlinx.dataframe.ColumnGroupReference] to create
+     * an accessor for a frame column inside a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`<`[String][String]`>("frameColA") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`(SomeType::frameColB) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`(1) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { `[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`("pathTo"["frameColumnName"] ) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { `[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`<`[String][String]`>("pathTo"["frameColumnName"] ) }`
+     *
+     * To create a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for another kind of column, take a look at the functions
+     * [col][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.col],
+     * [colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup],
+     * and [valueCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.valueCol].
+     *
+     * @return A [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for the frame column with the given argument if possible, else a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn].
+     * @throws [IllegalStateException] if the column with the given argument does not exist.
+     * @throws [IllegalArgumentException] if the column with the given argument is not a frame column.
+     *
+     * @see [frameColumn]
+     * @see [ColumnsSelectionDsl.colGroup]
+     * @see [ColumnsSelectionDsl.valueCol]
+     * @see [ColumnsSelectionDsl.col]
+     *
+     *
+     *
+     * @param [path] The path to the value column.
+     */
+    private interface FrameColPathDocs
+
+    /**
+     * ## Frame Col
+     *
+     * Creates a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] (or [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]) for a frame column with the given argument which can be either
+     * an index ([Int]) or a reference to a column
+     * ([String], [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath], [KProperty], or [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor]; any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+     *
+     * This is a DSL-shorthand for [frameColumn][org.jetbrains.kotlinx.dataframe.api.frameColumn] and can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index). In addition, extra runtime checks are in place to ensure that the column
+     * you specify is actually a frame column.
+     * The function can also be called on [ColumnGroups][org.jetbrains.kotlinx.dataframe.ColumnGroupReference] to create
+     * an accessor for a frame column inside a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`<`[String][String]`>("frameColA") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`(SomeType::frameColB) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`(1) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { `[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`("pathTo"["frameColumnName"] ) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { `[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`<`[String][String]`>("pathTo"["frameColumnName"] ) }`
+     *
+     * To create a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for another kind of column, take a look at the functions
+     * [col][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.col],
+     * [colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup],
+     * and [valueCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.valueCol].
+     *
+     * @return A [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for the frame column with the given argument if possible, else a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn].
+     * @throws [IllegalStateException] if the column with the given argument does not exist.
+     * @throws [IllegalArgumentException] if the column with the given argument is not a frame column.
+     *
+     * @see [frameColumn]
+     * @see [ColumnsSelectionDsl.colGroup]
+     * @see [ColumnsSelectionDsl.valueCol]
+     * @see [ColumnsSelectionDsl.col]
+     *
+     *
+     *
+     * @param [path] The path to the value column.
+     */
+    @Suppress("INAPPLICABLE_JVM_NAME")
+    @JvmName("frameColUnTyped")
+    public fun frameCol(path: ColumnPath): ColumnAccessor<DataFrame<*>> = frameColumn<Any?>(path).ensureIsFrameColumn()
+
+    /**
+     * ## Frame Col
+     *
+     * Creates a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] (or [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]) for a frame column with the given argument which can be either
+     * an index ([Int]) or a reference to a column
+     * ([String], [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath], [KProperty], or [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor]; any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+     *
+     * This is a DSL-shorthand for [frameColumn][org.jetbrains.kotlinx.dataframe.api.frameColumn] and can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index). In addition, extra runtime checks are in place to ensure that the column
+     * you specify is actually a frame column.
+     * The function can also be called on [ColumnGroups][org.jetbrains.kotlinx.dataframe.ColumnGroupReference] to create
+     * an accessor for a frame column inside a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`<`[String][String]`>("frameColA") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`(SomeType::frameColB) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`(1) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { `[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`("pathTo"["frameColumnName"] ) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { `[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`<`[String][String]`>("pathTo"["frameColumnName"] ) }`
+     *
+     * To create a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for another kind of column, take a look at the functions
+     * [col][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.col],
+     * [colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup],
+     * and [valueCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.valueCol].
+     *
+     * @return A [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for the frame column with the given argument if possible, else a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn].
+     * @throws [IllegalStateException] if the column with the given argument does not exist.
+     * @throws [IllegalArgumentException] if the column with the given argument is not a frame column.
+     *
+     * @see [frameColumn]
+     * @see [ColumnsSelectionDsl.colGroup]
+     * @see [ColumnsSelectionDsl.valueCol]
+     * @see [ColumnsSelectionDsl.col]
+     *
+     *
+     *
+     * @param [path] The path to the value column.
+     * @param [C] The type of the frame column.
+     */
+    public fun <C> frameCol(path: ColumnPath): ColumnAccessor<DataFrame<C>> = frameColumn<C>(path).ensureIsFrameColumn()
+
+    /**
+     * ## Frame Col
+     *
+     * Creates a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] (or [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]) for a frame column with the given argument which can be either
+     * an index ([Int]) or a reference to a column
+     * ([String], [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath], [KProperty], or [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor]; any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+     *
+     * This is a DSL-shorthand for [frameColumn][org.jetbrains.kotlinx.dataframe.api.frameColumn] and can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index). In addition, extra runtime checks are in place to ensure that the column
+     * you specify is actually a frame column.
+     * The function can also be called on [ColumnGroups][org.jetbrains.kotlinx.dataframe.ColumnGroupReference] to create
+     * an accessor for a frame column inside a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`<`[String][String]`>("frameColA") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`(SomeType::frameColB) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`(1) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`("pathTo"["frameColumnName"] ) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`<`[String][String]`>("pathTo"["frameColumnName"] ) }`
+     *
+     * To create a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for another kind of column, take a look at the functions
+     * [col][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.col],
+     * [colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup],
+     * and [valueCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.valueCol].
+     *
+     * @return A [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for the frame column with the given argument if possible, else a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn].
+     * @throws [IllegalStateException] if the column with the given argument does not exist.
+     * @throws [IllegalArgumentException] if the column with the given argument is not a frame column.
+     *
+     * @see [frameColumn]
+     * @see [ColumnsSelectionDsl.colGroup]
+     * @see [ColumnsSelectionDsl.valueCol]
+     * @see [ColumnsSelectionDsl.col]
+     *
+     *
+     *
+     * @param [path] The path to the value column.
+     */
+    @Suppress("INAPPLICABLE_JVM_NAME")
+    @JvmName("frameColUnTyped")
+    public fun SingleColumn<DataRow<*>>.frameCol(path: ColumnPath): SingleColumn<DataFrame<*>> = frameCol<Any?>(path)
+
+    /**
+     * ## Frame Col
+     *
+     * Creates a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] (or [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]) for a frame column with the given argument which can be either
+     * an index ([Int]) or a reference to a column
+     * ([String], [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath], [KProperty], or [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor]; any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+     *
+     * This is a DSL-shorthand for [frameColumn][org.jetbrains.kotlinx.dataframe.api.frameColumn] and can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index). In addition, extra runtime checks are in place to ensure that the column
+     * you specify is actually a frame column.
+     * The function can also be called on [ColumnGroups][org.jetbrains.kotlinx.dataframe.ColumnGroupReference] to create
+     * an accessor for a frame column inside a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`<`[String][String]`>("frameColA") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`(SomeType::frameColB) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`(1) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`("pathTo"["frameColumnName"] ) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`<`[String][String]`>("pathTo"["frameColumnName"] ) }`
+     *
+     * To create a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for another kind of column, take a look at the functions
+     * [col][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.col],
+     * [colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup],
+     * and [valueCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.valueCol].
+     *
+     * @return A [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for the frame column with the given argument if possible, else a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn].
+     * @throws [IllegalStateException] if the column with the given argument does not exist.
+     * @throws [IllegalArgumentException] if the column with the given argument is not a frame column.
+     *
+     * @see [frameColumn]
+     * @see [ColumnsSelectionDsl.colGroup]
+     * @see [ColumnsSelectionDsl.valueCol]
+     * @see [ColumnsSelectionDsl.col]
+     *
+     *
+     *
+     * @param [path] The path to the value column.
+     * @param [C] The type of the frame column.
+     */
+    public fun <C> SingleColumn<DataRow<*>>.frameCol(path: ColumnPath): SingleColumn<DataFrame<C>> =
+        this.ensureIsColumnGroup().transformSingle {
+            val child = it.getCol(path)?.cast<DataFrame<C>>()
+                ?: throw IllegalStateException("Frame column '$path' not found in column group '${it.path}'")
+            child.data.ensureIsFrameColumn()
+            listOf(child)
+        }.singleImpl()
+
+    /**
+     * ## Frame Col
+     *
+     * Creates a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] (or [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]) for a frame column with the given argument which can be either
+     * an index ([Int]) or a reference to a column
+     * ([String], [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath], [KProperty], or [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor]; any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+     *
+     * This is a DSL-shorthand for [frameColumn][org.jetbrains.kotlinx.dataframe.api.frameColumn] and can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index). In addition, extra runtime checks are in place to ensure that the column
+     * you specify is actually a frame column.
+     * The function can also be called on [ColumnGroups][org.jetbrains.kotlinx.dataframe.ColumnGroupReference] to create
+     * an accessor for a frame column inside a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`<`[String][String]`>("frameColA") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`(SomeType::frameColB) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`(1) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`("pathTo"["frameColumnName"] ) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`<`[String][String]`>("pathTo"["frameColumnName"] ) }`
+     *
+     * To create a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for another kind of column, take a look at the functions
+     * [col][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.col],
+     * [colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup],
+     * and [valueCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.valueCol].
+     *
+     * @return A [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for the frame column with the given argument if possible, else a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn].
+     * @throws [IllegalStateException] if the column with the given argument does not exist.
+     * @throws [IllegalArgumentException] if the column with the given argument is not a frame column.
+     *
+     * @see [frameColumn]
+     * @see [ColumnsSelectionDsl.colGroup]
+     * @see [ColumnsSelectionDsl.valueCol]
+     * @see [ColumnsSelectionDsl.col]
+     *
+     *
+     *
+     * @param [path] The path to the value column.
+     */
+    @Suppress("INAPPLICABLE_JVM_NAME")
+    @JvmName("frameColUnTyped")
+    public fun AnyColumnGroupAccessor.frameCol(path: ColumnPath): ColumnAccessor<DataFrame<*>> = frameCol<Any?>(path)
+
+    /**
+     * ## Frame Col
+     *
+     * Creates a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] (or [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]) for a frame column with the given argument which can be either
+     * an index ([Int]) or a reference to a column
+     * ([String], [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath], [KProperty], or [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor]; any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+     *
+     * This is a DSL-shorthand for [frameColumn][org.jetbrains.kotlinx.dataframe.api.frameColumn] and can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index). In addition, extra runtime checks are in place to ensure that the column
+     * you specify is actually a frame column.
+     * The function can also be called on [ColumnGroups][org.jetbrains.kotlinx.dataframe.ColumnGroupReference] to create
+     * an accessor for a frame column inside a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`<`[String][String]`>("frameColA") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`(SomeType::frameColB) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`(1) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`("pathTo"["frameColumnName"] ) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`<`[String][String]`>("pathTo"["frameColumnName"] ) }`
+     *
+     * To create a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for another kind of column, take a look at the functions
+     * [col][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.col],
+     * [colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup],
+     * and [valueCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.valueCol].
+     *
+     * @return A [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for the frame column with the given argument if possible, else a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn].
+     * @throws [IllegalStateException] if the column with the given argument does not exist.
+     * @throws [IllegalArgumentException] if the column with the given argument is not a frame column.
+     *
+     * @see [frameColumn]
+     * @see [ColumnsSelectionDsl.colGroup]
+     * @see [ColumnsSelectionDsl.valueCol]
+     * @see [ColumnsSelectionDsl.col]
+     *
+     *
+     *
+     * @param [path] The path to the value column.
+     * @param [C] The type of the frame column.
+     */
+    public fun <C> AnyColumnGroupAccessor.frameCol(path: ColumnPath): ColumnAccessor<DataFrame<C>> =
+        this.ensureIsColumnGroup().frameColumn<C>(path).ensureIsFrameColumn()
+
+    /**
+     * ## Frame Col
+     *
+     * Creates a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] (or [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]) for a frame column with the given argument which can be either
+     * an index ([Int]) or a reference to a column
+     * ([String], [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath], [KProperty], or [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor]; any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+     *
+     * This is a DSL-shorthand for [frameColumn][org.jetbrains.kotlinx.dataframe.api.frameColumn] and can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index). In addition, extra runtime checks are in place to ensure that the column
+     * you specify is actually a frame column.
+     * The function can also be called on [ColumnGroups][org.jetbrains.kotlinx.dataframe.ColumnGroupReference] to create
+     * an accessor for a frame column inside a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`<`[String][String]`>("frameColA") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`(SomeType::frameColB) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`(1) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "myColumnGroup".`[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`("pathTo"["frameColumnName"] ) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "myColumnGroup".`[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`<`[String][String]`>("pathTo"["frameColumnName"] ) }`
+     *
+     * To create a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for another kind of column, take a look at the functions
+     * [col][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.col],
+     * [colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup],
+     * and [valueCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.valueCol].
+     *
+     * @return A [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for the frame column with the given argument if possible, else a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn].
+     * @throws [IllegalStateException] if the column with the given argument does not exist.
+     * @throws [IllegalArgumentException] if the column with the given argument is not a frame column.
+     *
+     * @see [frameColumn]
+     * @see [ColumnsSelectionDsl.colGroup]
+     * @see [ColumnsSelectionDsl.valueCol]
+     * @see [ColumnsSelectionDsl.col]
+     *
+     *
+     *
+     * @param [path] The path to the value column.
+     */
+    @Suppress("INAPPLICABLE_JVM_NAME")
+    @JvmName("frameColUnTyped")
+    public fun String.frameCol(path: ColumnPath): ColumnAccessor<DataFrame<*>> = frameCol<Any?>(path)
+
+    /**
+     * ## Frame Col
+     *
+     * Creates a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] (or [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]) for a frame column with the given argument which can be either
+     * an index ([Int]) or a reference to a column
+     * ([String], [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath], [KProperty], or [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor]; any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+     *
+     * This is a DSL-shorthand for [frameColumn][org.jetbrains.kotlinx.dataframe.api.frameColumn] and can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index). In addition, extra runtime checks are in place to ensure that the column
+     * you specify is actually a frame column.
+     * The function can also be called on [ColumnGroups][org.jetbrains.kotlinx.dataframe.ColumnGroupReference] to create
+     * an accessor for a frame column inside a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`<`[String][String]`>("frameColA") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`(SomeType::frameColB) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`(1) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "myColumnGroup".`[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`("pathTo"["frameColumnName"] ) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "myColumnGroup".`[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`<`[String][String]`>("pathTo"["frameColumnName"] ) }`
+     *
+     * To create a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for another kind of column, take a look at the functions
+     * [col][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.col],
+     * [colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup],
+     * and [valueCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.valueCol].
+     *
+     * @return A [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for the frame column with the given argument if possible, else a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn].
+     * @throws [IllegalStateException] if the column with the given argument does not exist.
+     * @throws [IllegalArgumentException] if the column with the given argument is not a frame column.
+     *
+     * @see [frameColumn]
+     * @see [ColumnsSelectionDsl.colGroup]
+     * @see [ColumnsSelectionDsl.valueCol]
+     * @see [ColumnsSelectionDsl.col]
+     *
+     *
+     *
+     * @param [path] The path to the value column.
+     * @param [C] The type of the frame column.
+     */
+    public fun <C> String.frameCol(path: ColumnPath): ColumnAccessor<DataFrame<C>> =
+        columnGroup(this).ensureIsColumnGroup().frameColumn<C>(path).ensureIsFrameColumn()
+
+    /**
+     * ## Frame Col
+     *
+     * Creates a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] (or [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]) for a frame column with the given argument which can be either
+     * an index ([Int]) or a reference to a column
+     * ([String], [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath], [KProperty], or [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor]; any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+     *
+     * This is a DSL-shorthand for [frameColumn][org.jetbrains.kotlinx.dataframe.api.frameColumn] and can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index). In addition, extra runtime checks are in place to ensure that the column
+     * you specify is actually a frame column.
+     * The function can also be called on [ColumnGroups][org.jetbrains.kotlinx.dataframe.ColumnGroupReference] to create
+     * an accessor for a frame column inside a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`<`[String][String]`>("frameColA") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`(SomeType::frameColB) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`(1) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { Type::myColumnGroup.`[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`("pathTo"["frameColumnName"] ) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { Type::myColumnGroup.`[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`<`[String][String]`>("pathTo"["frameColumnName"] ) }`
+     *
+     * To create a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for another kind of column, take a look at the functions
+     * [col][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.col],
+     * [colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup],
+     * and [valueCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.valueCol].
+     *
+     * @return A [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for the frame column with the given argument if possible, else a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn].
+     * @throws [IllegalStateException] if the column with the given argument does not exist.
+     * @throws [IllegalArgumentException] if the column with the given argument is not a frame column.
+     *
+     * @see [frameColumn]
+     * @see [ColumnsSelectionDsl.colGroup]
+     * @see [ColumnsSelectionDsl.valueCol]
+     * @see [ColumnsSelectionDsl.col]
+     *
+     *
+     *
+     * @param [path] The path to the value column.
+     */
+    @Suppress("INAPPLICABLE_JVM_NAME")
+    @JvmName("frameColUnTyped")
+    public fun KProperty<*>.frameCol(path: ColumnPath): ColumnAccessor<DataFrame<*>> = frameCol<Any?>(path)
+
+    /**
+     * ## Frame Col
+     *
+     * Creates a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] (or [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]) for a frame column with the given argument which can be either
+     * an index ([Int]) or a reference to a column
+     * ([String], [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath], [KProperty], or [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor]; any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+     *
+     * This is a DSL-shorthand for [frameColumn][org.jetbrains.kotlinx.dataframe.api.frameColumn] and can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index). In addition, extra runtime checks are in place to ensure that the column
+     * you specify is actually a frame column.
+     * The function can also be called on [ColumnGroups][org.jetbrains.kotlinx.dataframe.ColumnGroupReference] to create
+     * an accessor for a frame column inside a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`<`[String][String]`>("frameColA") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`(SomeType::frameColB) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`(1) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { Type::myColumnGroup.`[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`("pathTo"["frameColumnName"] ) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { Type::myColumnGroup.`[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`<`[String][String]`>("pathTo"["frameColumnName"] ) }`
+     *
+     * To create a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for another kind of column, take a look at the functions
+     * [col][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.col],
+     * [colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup],
+     * and [valueCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.valueCol].
+     *
+     * @return A [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for the frame column with the given argument if possible, else a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn].
+     * @throws [IllegalStateException] if the column with the given argument does not exist.
+     * @throws [IllegalArgumentException] if the column with the given argument is not a frame column.
+     *
+     * @see [frameColumn]
+     * @see [ColumnsSelectionDsl.colGroup]
+     * @see [ColumnsSelectionDsl.valueCol]
+     * @see [ColumnsSelectionDsl.col]
+     *
+     *
+     *
+     * @param [path] The path to the value column.
+     * @param [C] The type of the frame column.
+     */
+    public fun <C> KProperty<*>.frameCol(path: ColumnPath): ColumnAccessor<DataFrame<C>> =
+        columnGroup(this).ensureIsColumnGroup().frameColumn<C>(path).ensureIsFrameColumn()
+
+    /**
+     * ## Frame Col
+     *
+     * Creates a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] (or [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]) for a frame column with the given argument which can be either
+     * an index ([Int]) or a reference to a column
+     * ([String], [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath], [KProperty], or [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor]; any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+     *
+     * This is a DSL-shorthand for [frameColumn][org.jetbrains.kotlinx.dataframe.api.frameColumn] and can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index). In addition, extra runtime checks are in place to ensure that the column
+     * you specify is actually a frame column.
+     * The function can also be called on [ColumnGroups][org.jetbrains.kotlinx.dataframe.ColumnGroupReference] to create
+     * an accessor for a frame column inside a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`<`[String][String]`>("frameColA") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`(SomeType::frameColB) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`(1) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "pathTo"["myColumnGroup"].`[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`("pathTo"["frameColumnName"] ) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "pathTo"["myColumnGroup"].`[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`<`[String][String]`>("pathTo"["frameColumnName"] ) }`
+     *
+     * To create a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for another kind of column, take a look at the functions
+     * [col][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.col],
+     * [colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup],
+     * and [valueCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.valueCol].
+     *
+     * @return A [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for the frame column with the given argument if possible, else a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn].
+     * @throws [IllegalStateException] if the column with the given argument does not exist.
+     * @throws [IllegalArgumentException] if the column with the given argument is not a frame column.
+     *
+     * @see [frameColumn]
+     * @see [ColumnsSelectionDsl.colGroup]
+     * @see [ColumnsSelectionDsl.valueCol]
+     * @see [ColumnsSelectionDsl.col]
+     *
+     *
+     *
+     * @param [path] The path to the value column.
+     */
+    @Suppress("INAPPLICABLE_JVM_NAME")
+    @JvmName("frameColUnTyped")
+    public fun ColumnPath.frameCol(path: ColumnPath): ColumnAccessor<DataFrame<*>> = frameCol<Any?>(path)
+
+    /**
+     * ## Frame Col
+     *
+     * Creates a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] (or [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]) for a frame column with the given argument which can be either
+     * an index ([Int]) or a reference to a column
+     * ([String], [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath], [KProperty], or [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor]; any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+     *
+     * This is a DSL-shorthand for [frameColumn][org.jetbrains.kotlinx.dataframe.api.frameColumn] and can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index). In addition, extra runtime checks are in place to ensure that the column
+     * you specify is actually a frame column.
+     * The function can also be called on [ColumnGroups][org.jetbrains.kotlinx.dataframe.ColumnGroupReference] to create
+     * an accessor for a frame column inside a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`<`[String][String]`>("frameColA") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`(SomeType::frameColB) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`(1) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "pathTo"["myColumnGroup"].`[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`("pathTo"["frameColumnName"] ) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "pathTo"["myColumnGroup"].`[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`<`[String][String]`>("pathTo"["frameColumnName"] ) }`
+     *
+     * To create a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for another kind of column, take a look at the functions
+     * [col][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.col],
+     * [colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup],
+     * and [valueCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.valueCol].
+     *
+     * @return A [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for the frame column with the given argument if possible, else a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn].
+     * @throws [IllegalStateException] if the column with the given argument does not exist.
+     * @throws [IllegalArgumentException] if the column with the given argument is not a frame column.
+     *
+     * @see [frameColumn]
+     * @see [ColumnsSelectionDsl.colGroup]
+     * @see [ColumnsSelectionDsl.valueCol]
+     * @see [ColumnsSelectionDsl.col]
+     *
+     *
+     *
+     * @param [path] The path to the value column.
+     * @param [C] The type of the frame column.
+     */
+    public fun <C> ColumnPath.frameCol(path: ColumnPath): ColumnAccessor<DataFrame<C>> =
+        columnGroup(this).ensureIsColumnGroup().frameColumn<C>(path).ensureIsFrameColumn()
+
+    // endregion
+
+    // region property
+
+    /**
+     * ## Frame Col
+     *
+     * Creates a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] (or [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]) for a frame column with the given argument which can be either
+     * an index ([Int]) or a reference to a column
+     * ([String], [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath], [KProperty], or [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor]; any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+     *
+     * This is a DSL-shorthand for [frameColumn][org.jetbrains.kotlinx.dataframe.api.frameColumn] and can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index). In addition, extra runtime checks are in place to ensure that the column
+     * you specify is actually a frame column.
+     * The function can also be called on [ColumnGroups][org.jetbrains.kotlinx.dataframe.ColumnGroupReference] to create
+     * an accessor for a frame column inside a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`<`[String][String]`>("frameColA") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`(SomeType::frameColB) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`(1) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { `[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`(Type::frameColumnA) }`
+     *
+     * To create a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for another kind of column, take a look at the functions
+     * [col][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.col],
+     * [colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup],
+     * and [valueCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.valueCol].
+     *
+     * @return A [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for the frame column with the given argument if possible, else a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn].
+     * @throws [IllegalStateException] if the column with the given argument does not exist.
+     * @throws [IllegalArgumentException] if the column with the given argument is not a frame column.
+     *
+     * @see [frameColumn]
+     * @see [ColumnsSelectionDsl.colGroup]
+     * @see [ColumnsSelectionDsl.valueCol]
+     * @see [ColumnsSelectionDsl.col]
+     *
+     *
+     *
+     * @param [property] The [KProperty] reference to the value column.
+     * @param [C] The type of the frame column.
+     */
+    private interface FrameColKPropertyDocs
+
+    /**
+     * ## Frame Col
+     *
+     * Creates a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] (or [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]) for a frame column with the given argument which can be either
+     * an index ([Int]) or a reference to a column
+     * ([String], [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath], [KProperty], or [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor]; any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+     *
+     * This is a DSL-shorthand for [frameColumn][org.jetbrains.kotlinx.dataframe.api.frameColumn] and can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index). In addition, extra runtime checks are in place to ensure that the column
+     * you specify is actually a frame column.
+     * The function can also be called on [ColumnGroups][org.jetbrains.kotlinx.dataframe.ColumnGroupReference] to create
+     * an accessor for a frame column inside a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`<`[String][String]`>("frameColA") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`(SomeType::frameColB) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`(1) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { `[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`(Type::frameColumnA) }`
+     *
+     * To create a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for another kind of column, take a look at the functions
+     * [col][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.col],
+     * [colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup],
+     * and [valueCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.valueCol].
+     *
+     * @return A [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for the frame column with the given argument if possible, else a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn].
+     * @throws [IllegalStateException] if the column with the given argument does not exist.
+     * @throws [IllegalArgumentException] if the column with the given argument is not a frame column.
+     *
+     * @see [frameColumn]
+     * @see [ColumnsSelectionDsl.colGroup]
+     * @see [ColumnsSelectionDsl.valueCol]
+     * @see [ColumnsSelectionDsl.col]
+     *
+     *
+     *
+     * @param [property] The [KProperty] reference to the value column.
+     * @param [C] The type of the frame column.
+     */
+    @Suppress("INAPPLICABLE_JVM_NAME")
+    @JvmName("frameColDataFrameKProperty")
+    public fun <C> frameCol(property: KProperty<DataFrame<C>>): SingleColumn<DataFrame<C>> =
+        frameColumn(property).ensureIsFrameColumn()
+
+    /**
+     * ## Frame Col
+     *
+     * Creates a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] (or [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]) for a frame column with the given argument which can be either
+     * an index ([Int]) or a reference to a column
+     * ([String], [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath], [KProperty], or [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor]; any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+     *
+     * This is a DSL-shorthand for [frameColumn][org.jetbrains.kotlinx.dataframe.api.frameColumn] and can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index). In addition, extra runtime checks are in place to ensure that the column
+     * you specify is actually a frame column.
+     * The function can also be called on [ColumnGroups][org.jetbrains.kotlinx.dataframe.ColumnGroupReference] to create
+     * an accessor for a frame column inside a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`<`[String][String]`>("frameColA") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`(SomeType::frameColB) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`(1) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { `[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`(Type::frameColumnA) }`
+     *
+     * To create a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for another kind of column, take a look at the functions
+     * [col][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.col],
+     * [colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup],
+     * and [valueCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.valueCol].
+     *
+     * @return A [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for the frame column with the given argument if possible, else a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn].
+     * @throws [IllegalStateException] if the column with the given argument does not exist.
+     * @throws [IllegalArgumentException] if the column with the given argument is not a frame column.
+     *
+     * @see [frameColumn]
+     * @see [ColumnsSelectionDsl.colGroup]
+     * @see [ColumnsSelectionDsl.valueCol]
+     * @see [ColumnsSelectionDsl.col]
+     *
+     *
+     *
+     * @param [property] The [KProperty] reference to the value column.
+     * @param [C] The type of the frame column.
+     */
+    public fun <C> frameCol(property: KProperty<List<C>>): SingleColumn<DataFrame<C>> =
+        frameColumn(property).ensureIsFrameColumn()
+
+    /**
+     * ## Frame Col
+     *
+     * Creates a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] (or [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]) for a frame column with the given argument which can be either
+     * an index ([Int]) or a reference to a column
+     * ([String], [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath], [KProperty], or [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor]; any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+     *
+     * This is a DSL-shorthand for [frameColumn][org.jetbrains.kotlinx.dataframe.api.frameColumn] and can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index). In addition, extra runtime checks are in place to ensure that the column
+     * you specify is actually a frame column.
+     * The function can also be called on [ColumnGroups][org.jetbrains.kotlinx.dataframe.ColumnGroupReference] to create
+     * an accessor for a frame column inside a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`<`[String][String]`>("frameColA") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`(SomeType::frameColB) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`(1) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`(Type::frameColumnA) }`
+     *
+     * To create a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for another kind of column, take a look at the functions
+     * [col][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.col],
+     * [colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup],
+     * and [valueCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.valueCol].
+     *
+     * @return A [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for the frame column with the given argument if possible, else a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn].
+     * @throws [IllegalStateException] if the column with the given argument does not exist.
+     * @throws [IllegalArgumentException] if the column with the given argument is not a frame column.
+     *
+     * @see [frameColumn]
+     * @see [ColumnsSelectionDsl.colGroup]
+     * @see [ColumnsSelectionDsl.valueCol]
+     * @see [ColumnsSelectionDsl.col]
+     *
+     *
+     *
+     * @param [property] The [KProperty] reference to the value column.
+     * @param [C] The type of the frame column.
+     */
+    @Suppress("INAPPLICABLE_JVM_NAME")
+    @JvmName("frameColDataFrameKProperty")
+    public fun <C> SingleColumn<DataRow<*>>.frameCol(property: KProperty<DataFrame<C>>): SingleColumn<DataFrame<C>> =
+        frameCol<C>(property.name)
+
+    /**
+     * ## Frame Col
+     *
+     * Creates a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] (or [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]) for a frame column with the given argument which can be either
+     * an index ([Int]) or a reference to a column
+     * ([String], [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath], [KProperty], or [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor]; any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+     *
+     * This is a DSL-shorthand for [frameColumn][org.jetbrains.kotlinx.dataframe.api.frameColumn] and can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index). In addition, extra runtime checks are in place to ensure that the column
+     * you specify is actually a frame column.
+     * The function can also be called on [ColumnGroups][org.jetbrains.kotlinx.dataframe.ColumnGroupReference] to create
+     * an accessor for a frame column inside a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`<`[String][String]`>("frameColA") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`(SomeType::frameColB) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`(1) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`(Type::frameColumnA) }`
+     *
+     * To create a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for another kind of column, take a look at the functions
+     * [col][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.col],
+     * [colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup],
+     * and [valueCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.valueCol].
+     *
+     * @return A [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for the frame column with the given argument if possible, else a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn].
+     * @throws [IllegalStateException] if the column with the given argument does not exist.
+     * @throws [IllegalArgumentException] if the column with the given argument is not a frame column.
+     *
+     * @see [frameColumn]
+     * @see [ColumnsSelectionDsl.colGroup]
+     * @see [ColumnsSelectionDsl.valueCol]
+     * @see [ColumnsSelectionDsl.col]
+     *
+     *
+     *
+     * @param [property] The [KProperty] reference to the value column.
+     * @param [C] The type of the frame column.
+     */
+    public fun <C> SingleColumn<DataRow<*>>.frameCol(property: KProperty<List<C>>): SingleColumn<DataFrame<C>> =
+        frameCol<C>(property.name)
+
+    /**
+     * ## Frame Col
+     *
+     * Creates a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] (or [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]) for a frame column with the given argument which can be either
+     * an index ([Int]) or a reference to a column
+     * ([String], [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath], [KProperty], or [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor]; any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+     *
+     * This is a DSL-shorthand for [frameColumn][org.jetbrains.kotlinx.dataframe.api.frameColumn] and can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index). In addition, extra runtime checks are in place to ensure that the column
+     * you specify is actually a frame column.
+     * The function can also be called on [ColumnGroups][org.jetbrains.kotlinx.dataframe.ColumnGroupReference] to create
+     * an accessor for a frame column inside a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`<`[String][String]`>("frameColA") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`(SomeType::frameColB) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`(1) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`(Type::frameColumnA) }`
+     *
+     * To create a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for another kind of column, take a look at the functions
+     * [col][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.col],
+     * [colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup],
+     * and [valueCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.valueCol].
+     *
+     * @return A [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for the frame column with the given argument if possible, else a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn].
+     * @throws [IllegalStateException] if the column with the given argument does not exist.
+     * @throws [IllegalArgumentException] if the column with the given argument is not a frame column.
+     *
+     * @see [frameColumn]
+     * @see [ColumnsSelectionDsl.colGroup]
+     * @see [ColumnsSelectionDsl.valueCol]
+     * @see [ColumnsSelectionDsl.col]
+     *
+     *
+     *
+     * @param [property] The [KProperty] reference to the value column.
+     * @param [C] The type of the frame column.
+     */
+    @Suppress("INAPPLICABLE_JVM_NAME")
+    @JvmName("frameColDataFrameKProperty")
+    public fun <C> AnyColumnGroupAccessor.frameCol(property: KProperty<DataFrame<C>>): ColumnAccessor<DataFrame<C>> =
+        this.ensureIsColumnGroup().frameColumn(property).ensureIsFrameColumn()
+
+    /**
+     * ## Frame Col
+     *
+     * Creates a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] (or [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]) for a frame column with the given argument which can be either
+     * an index ([Int]) or a reference to a column
+     * ([String], [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath], [KProperty], or [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor]; any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+     *
+     * This is a DSL-shorthand for [frameColumn][org.jetbrains.kotlinx.dataframe.api.frameColumn] and can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index). In addition, extra runtime checks are in place to ensure that the column
+     * you specify is actually a frame column.
+     * The function can also be called on [ColumnGroups][org.jetbrains.kotlinx.dataframe.ColumnGroupReference] to create
+     * an accessor for a frame column inside a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`<`[String][String]`>("frameColA") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`(SomeType::frameColB) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`(1) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`(Type::frameColumnA) }`
+     *
+     * To create a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for another kind of column, take a look at the functions
+     * [col][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.col],
+     * [colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup],
+     * and [valueCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.valueCol].
+     *
+     * @return A [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for the frame column with the given argument if possible, else a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn].
+     * @throws [IllegalStateException] if the column with the given argument does not exist.
+     * @throws [IllegalArgumentException] if the column with the given argument is not a frame column.
+     *
+     * @see [frameColumn]
+     * @see [ColumnsSelectionDsl.colGroup]
+     * @see [ColumnsSelectionDsl.valueCol]
+     * @see [ColumnsSelectionDsl.col]
+     *
+     *
+     *
+     * @param [property] The [KProperty] reference to the value column.
+     * @param [C] The type of the frame column.
+     */
+    public fun <C> AnyColumnGroupAccessor.frameCol(property: KProperty<List<C>>): ColumnAccessor<DataFrame<C>> =
+        this.ensureIsColumnGroup().frameColumn(property).ensureIsFrameColumn()
+
+    /**
+     * ## Frame Col
+     *
+     * Creates a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] (or [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]) for a frame column with the given argument which can be either
+     * an index ([Int]) or a reference to a column
+     * ([String], [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath], [KProperty], or [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor]; any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+     *
+     * This is a DSL-shorthand for [frameColumn][org.jetbrains.kotlinx.dataframe.api.frameColumn] and can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index). In addition, extra runtime checks are in place to ensure that the column
+     * you specify is actually a frame column.
+     * The function can also be called on [ColumnGroups][org.jetbrains.kotlinx.dataframe.ColumnGroupReference] to create
+     * an accessor for a frame column inside a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`<`[String][String]`>("frameColA") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`(SomeType::frameColB) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`(1) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "myColumnGroup".`[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`(Type::frameColumnA) }`
+     *
+     * To create a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for another kind of column, take a look at the functions
+     * [col][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.col],
+     * [colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup],
+     * and [valueCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.valueCol].
+     *
+     * @return A [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for the frame column with the given argument if possible, else a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn].
+     * @throws [IllegalStateException] if the column with the given argument does not exist.
+     * @throws [IllegalArgumentException] if the column with the given argument is not a frame column.
+     *
+     * @see [frameColumn]
+     * @see [ColumnsSelectionDsl.colGroup]
+     * @see [ColumnsSelectionDsl.valueCol]
+     * @see [ColumnsSelectionDsl.col]
+     *
+     *
+     *
+     * @param [property] The [KProperty] reference to the value column.
+     * @param [C] The type of the frame column.
+     */
+    @Suppress("INAPPLICABLE_JVM_NAME")
+    @JvmName("frameColDataFrameKProperty")
+    public fun <C> String.frameCol(property: KProperty<DataFrame<C>>): ColumnAccessor<DataFrame<C>> =
+        columnGroup(this).ensureIsColumnGroup().frameColumn(property).ensureIsFrameColumn()
+
+    /**
+     * ## Frame Col
+     *
+     * Creates a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] (or [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]) for a frame column with the given argument which can be either
+     * an index ([Int]) or a reference to a column
+     * ([String], [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath], [KProperty], or [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor]; any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+     *
+     * This is a DSL-shorthand for [frameColumn][org.jetbrains.kotlinx.dataframe.api.frameColumn] and can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index). In addition, extra runtime checks are in place to ensure that the column
+     * you specify is actually a frame column.
+     * The function can also be called on [ColumnGroups][org.jetbrains.kotlinx.dataframe.ColumnGroupReference] to create
+     * an accessor for a frame column inside a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`<`[String][String]`>("frameColA") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`(SomeType::frameColB) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`(1) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "myColumnGroup".`[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`(Type::frameColumnA) }`
+     *
+     * To create a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for another kind of column, take a look at the functions
+     * [col][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.col],
+     * [colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup],
+     * and [valueCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.valueCol].
+     *
+     * @return A [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for the frame column with the given argument if possible, else a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn].
+     * @throws [IllegalStateException] if the column with the given argument does not exist.
+     * @throws [IllegalArgumentException] if the column with the given argument is not a frame column.
+     *
+     * @see [frameColumn]
+     * @see [ColumnsSelectionDsl.colGroup]
+     * @see [ColumnsSelectionDsl.valueCol]
+     * @see [ColumnsSelectionDsl.col]
+     *
+     *
+     *
+     * @param [property] The [KProperty] reference to the value column.
+     * @param [C] The type of the frame column.
+     */
+    public fun <C> String.frameCol(property: KProperty<List<C>>): ColumnAccessor<DataFrame<C>> =
+        columnGroup(this).ensureIsColumnGroup().frameColumn(property).ensureIsFrameColumn()
+
+    /**
+     * ## Frame Col
+     *
+     * Creates a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] (or [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]) for a frame column with the given argument which can be either
+     * an index ([Int]) or a reference to a column
+     * ([String], [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath], [KProperty], or [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor]; any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+     *
+     * This is a DSL-shorthand for [frameColumn][org.jetbrains.kotlinx.dataframe.api.frameColumn] and can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index). In addition, extra runtime checks are in place to ensure that the column
+     * you specify is actually a frame column.
+     * The function can also be called on [ColumnGroups][org.jetbrains.kotlinx.dataframe.ColumnGroupReference] to create
+     * an accessor for a frame column inside a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`<`[String][String]`>("frameColA") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`(SomeType::frameColB) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`(1) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { Type::myColumnGroup.`[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`(Type::frameColumnA) }`
+     *
+     * To create a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for another kind of column, take a look at the functions
+     * [col][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.col],
+     * [colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup],
+     * and [valueCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.valueCol].
+     *
+     * @return A [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for the frame column with the given argument if possible, else a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn].
+     * @throws [IllegalStateException] if the column with the given argument does not exist.
+     * @throws [IllegalArgumentException] if the column with the given argument is not a frame column.
+     *
+     * @see [frameColumn]
+     * @see [ColumnsSelectionDsl.colGroup]
+     * @see [ColumnsSelectionDsl.valueCol]
+     * @see [ColumnsSelectionDsl.col]
+     *
+     *
+     *
+     * @param [property] The [KProperty] reference to the value column.
+     * @param [C] The type of the frame column.
+     */
+    @Suppress("INAPPLICABLE_JVM_NAME")
+    @JvmName("frameColDataFrameKProperty")
+    public fun <C> KProperty<*>.frameCol(property: KProperty<DataFrame<C>>): ColumnAccessor<DataFrame<C>> =
+        columnGroup(this).ensureIsColumnGroup().frameColumn(property).ensureIsFrameColumn()
+
+    /**
+     * ## Frame Col
+     *
+     * Creates a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] (or [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]) for a frame column with the given argument which can be either
+     * an index ([Int]) or a reference to a column
+     * ([String], [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath], [KProperty], or [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor]; any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+     *
+     * This is a DSL-shorthand for [frameColumn][org.jetbrains.kotlinx.dataframe.api.frameColumn] and can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index). In addition, extra runtime checks are in place to ensure that the column
+     * you specify is actually a frame column.
+     * The function can also be called on [ColumnGroups][org.jetbrains.kotlinx.dataframe.ColumnGroupReference] to create
+     * an accessor for a frame column inside a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`<`[String][String]`>("frameColA") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`(SomeType::frameColB) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`(1) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { Type::myColumnGroup.`[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`(Type::frameColumnA) }`
+     *
+     * To create a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for another kind of column, take a look at the functions
+     * [col][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.col],
+     * [colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup],
+     * and [valueCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.valueCol].
+     *
+     * @return A [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for the frame column with the given argument if possible, else a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn].
+     * @throws [IllegalStateException] if the column with the given argument does not exist.
+     * @throws [IllegalArgumentException] if the column with the given argument is not a frame column.
+     *
+     * @see [frameColumn]
+     * @see [ColumnsSelectionDsl.colGroup]
+     * @see [ColumnsSelectionDsl.valueCol]
+     * @see [ColumnsSelectionDsl.col]
+     *
+     *
+     *
+     * @param [property] The [KProperty] reference to the value column.
+     * @param [C] The type of the frame column.
+     */
+    public fun <C> KProperty<*>.frameCol(property: KProperty<List<C>>): ColumnAccessor<DataFrame<C>> =
+        columnGroup(this).ensureIsColumnGroup().frameColumn(property).ensureIsFrameColumn()
+
+    /**
+     * ## Frame Col
+     *
+     * Creates a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] (or [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]) for a frame column with the given argument which can be either
+     * an index ([Int]) or a reference to a column
+     * ([String], [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath], [KProperty], or [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor]; any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+     *
+     * This is a DSL-shorthand for [frameColumn][org.jetbrains.kotlinx.dataframe.api.frameColumn] and can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index). In addition, extra runtime checks are in place to ensure that the column
+     * you specify is actually a frame column.
+     * The function can also be called on [ColumnGroups][org.jetbrains.kotlinx.dataframe.ColumnGroupReference] to create
+     * an accessor for a frame column inside a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`<`[String][String]`>("frameColA") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`(SomeType::frameColB) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`(1) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "pathTo"["myColumnGroup"].`[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`(Type::frameColumnA) }`
+     *
+     * To create a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for another kind of column, take a look at the functions
+     * [col][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.col],
+     * [colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup],
+     * and [valueCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.valueCol].
+     *
+     * @return A [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for the frame column with the given argument if possible, else a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn].
+     * @throws [IllegalStateException] if the column with the given argument does not exist.
+     * @throws [IllegalArgumentException] if the column with the given argument is not a frame column.
+     *
+     * @see [frameColumn]
+     * @see [ColumnsSelectionDsl.colGroup]
+     * @see [ColumnsSelectionDsl.valueCol]
+     * @see [ColumnsSelectionDsl.col]
+     *
+     *
+     *
+     * @param [property] The [KProperty] reference to the value column.
+     * @param [C] The type of the frame column.
+     */
+    @Suppress("INAPPLICABLE_JVM_NAME")
+    @JvmName("frameColDataFrameKProperty")
+    public fun <C> ColumnPath.frameCol(property: KProperty<DataFrame<C>>): ColumnAccessor<DataFrame<C>> =
+        columnGroup(this).ensureIsColumnGroup().frameColumn(property).ensureIsFrameColumn()
+
+    /**
+     * ## Frame Col
+     *
+     * Creates a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] (or [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]) for a frame column with the given argument which can be either
+     * an index ([Int]) or a reference to a column
+     * ([String], [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath], [KProperty], or [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor]; any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+     *
+     * This is a DSL-shorthand for [frameColumn][org.jetbrains.kotlinx.dataframe.api.frameColumn] and can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index). In addition, extra runtime checks are in place to ensure that the column
+     * you specify is actually a frame column.
+     * The function can also be called on [ColumnGroups][org.jetbrains.kotlinx.dataframe.ColumnGroupReference] to create
+     * an accessor for a frame column inside a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`<`[String][String]`>("frameColA") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`(SomeType::frameColB) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`(1) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "pathTo"["myColumnGroup"].`[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`(Type::frameColumnA) }`
+     *
+     * To create a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for another kind of column, take a look at the functions
+     * [col][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.col],
+     * [colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup],
+     * and [valueCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.valueCol].
+     *
+     * @return A [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for the frame column with the given argument if possible, else a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn].
+     * @throws [IllegalStateException] if the column with the given argument does not exist.
+     * @throws [IllegalArgumentException] if the column with the given argument is not a frame column.
+     *
+     * @see [frameColumn]
+     * @see [ColumnsSelectionDsl.colGroup]
+     * @see [ColumnsSelectionDsl.valueCol]
+     * @see [ColumnsSelectionDsl.col]
+     *
+     *
+     *
+     * @param [property] The [KProperty] reference to the value column.
+     * @param [C] The type of the frame column.
+     */
+    public fun <C> ColumnPath.frameCol(property: KProperty<List<C>>): ColumnAccessor<DataFrame<C>> =
+        columnGroup(this).ensureIsColumnGroup().frameColumn(property).ensureIsFrameColumn()
+
+    // endregion
+
+    // region index
+
+    /**
+     * ## Frame Col
+     *
+     * Creates a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] (or [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]) for a frame column with the given argument which can be either
+     * an index ([Int]) or a reference to a column
+     * ([String], [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath], [KProperty], or [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor]; any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+     *
+     * This is a DSL-shorthand for [frameColumn][org.jetbrains.kotlinx.dataframe.api.frameColumn] and can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index). In addition, extra runtime checks are in place to ensure that the column
+     * you specify is actually a frame column.
+     * The function can also be called on [ColumnGroups][org.jetbrains.kotlinx.dataframe.ColumnGroupReference] to create
+     * an accessor for a frame column inside a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`<`[String][String]`>("frameColA") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`(SomeType::frameColB) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`(1) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { `[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`(0) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { `[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`<`[String][String]`>(0) }`
+     *
+     * To create a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for another kind of column, take a look at the functions
+     * [col][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.col],
+     * [colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup],
+     * and [valueCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.valueCol].
+     *
+     * @return A [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for the frame column with the given argument if possible, else a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn].
+     * @throws [IllegalStateException] if the column with the given argument does not exist.
+     * @throws [IllegalArgumentException] if the column with the given argument is not a frame column.
+     *
+     * @see [frameColumn]
+     * @see [ColumnsSelectionDsl.colGroup]
+     * @see [ColumnsSelectionDsl.valueCol]
+     * @see [ColumnsSelectionDsl.col]
+     *
+     *
+     *
+     * @param [index] The index of the value column.
+     * @throws [IndexOutOfBoundsException] if the index is out of bounds.
+     */
+    private interface FrameColIndexDocs
+
+    /**
+     * ## Frame Col
+     *
+     * Creates a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] (or [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]) for a frame column with the given argument which can be either
+     * an index ([Int]) or a reference to a column
+     * ([String], [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath], [KProperty], or [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor]; any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+     *
+     * This is a DSL-shorthand for [frameColumn][org.jetbrains.kotlinx.dataframe.api.frameColumn] and can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index). In addition, extra runtime checks are in place to ensure that the column
+     * you specify is actually a frame column.
+     * The function can also be called on [ColumnGroups][org.jetbrains.kotlinx.dataframe.ColumnGroupReference] to create
+     * an accessor for a frame column inside a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`<`[String][String]`>("frameColA") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`(SomeType::frameColB) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`(1) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { `[colsOf][ColumnsSelectionDsl.colsOf]`<`[Int][Int]`>().`[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`(0) }`
+     *
+     * To create a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for another kind of column, take a look at the functions
+     * [col][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.col],
+     * [colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup],
+     * and [valueCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.valueCol].
+     *
+     * @return A [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for the frame column with the given argument if possible, else a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn].
+     * @throws [IllegalStateException] if the column with the given argument does not exist.
+     * @throws [IllegalArgumentException] if the column with the given argument is not a frame column.
+     *
+     * @see [frameColumn]
+     * @see [ColumnsSelectionDsl.colGroup]
+     * @see [ColumnsSelectionDsl.valueCol]
+     * @see [ColumnsSelectionDsl.col]
+     *
+     *
+     *
+     * @param [index] The index of the value column.
+     * @throws [IndexOutOfBoundsException] if the index is out of bounds.
+     * @param [C] The type of the frame column.
+     *
+     */
+    @Suppress("INAPPLICABLE_JVM_NAME")
+    @JvmName("ColumnSetDataFrameFrameColIndex")
+    public fun <C> ColumnSet<DataFrame<C>>.frameCol(index: Int): SingleColumn<DataFrame<C>> =
+        getAt(index).ensureIsFrameColumn()
+
+    /**
+     * ## Frame Col
+     *
+     * Creates a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] (or [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]) for a frame column with the given argument which can be either
+     * an index ([Int]) or a reference to a column
+     * ([String], [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath], [KProperty], or [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor]; any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+     *
+     * This is a DSL-shorthand for [frameColumn][org.jetbrains.kotlinx.dataframe.api.frameColumn] and can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index). In addition, extra runtime checks are in place to ensure that the column
+     * you specify is actually a frame column.
+     * The function can also be called on [ColumnGroups][org.jetbrains.kotlinx.dataframe.ColumnGroupReference] to create
+     * an accessor for a frame column inside a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`<`[String][String]`>("frameColA") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`(SomeType::frameColB) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`(1) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { `[colsOf][ColumnsSelectionDsl.colsOf]`<`[Int][Int]`>().`[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`(0) }`
+     *
+     * To create a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for another kind of column, take a look at the functions
+     * [col][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.col],
+     * [colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup],
+     * and [valueCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.valueCol].
+     *
+     * @return A [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for the frame column with the given argument if possible, else a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn].
+     * @throws [IllegalStateException] if the column with the given argument does not exist.
+     * @throws [IllegalArgumentException] if the column with the given argument is not a frame column.
+     *
+     * @see [frameColumn]
+     * @see [ColumnsSelectionDsl.colGroup]
+     * @see [ColumnsSelectionDsl.valueCol]
+     * @see [ColumnsSelectionDsl.col]
+     *
+     *
+     *
+     * @param [index] The index of the value column.
+     * @throws [IndexOutOfBoundsException] if the index is out of bounds.
+     * @param [C] The type of the frame column.
+     *
+     */
+    public fun ColumnSet<*>.frameCol(index: Int): SingleColumn<DataFrame<*>> =
+        getAt(index).cast<DataFrame<*>>().ensureIsFrameColumn()
+
+    /**
+     * ## Frame Col
+     *
+     * Creates a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] (or [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]) for a frame column with the given argument which can be either
+     * an index ([Int]) or a reference to a column
+     * ([String], [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath], [KProperty], or [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor]; any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+     *
+     * This is a DSL-shorthand for [frameColumn][org.jetbrains.kotlinx.dataframe.api.frameColumn] and can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index). In addition, extra runtime checks are in place to ensure that the column
+     * you specify is actually a frame column.
+     * The function can also be called on [ColumnGroups][org.jetbrains.kotlinx.dataframe.ColumnGroupReference] to create
+     * an accessor for a frame column inside a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`<`[String][String]`>("frameColA") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`(SomeType::frameColB) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`(1) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { `[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`(0) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { `[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`<`[String][String]`>(0) }`
+     *
+     * To create a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for another kind of column, take a look at the functions
+     * [col][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.col],
+     * [colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup],
+     * and [valueCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.valueCol].
+     *
+     * @return A [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for the frame column with the given argument if possible, else a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn].
+     * @throws [IllegalStateException] if the column with the given argument does not exist.
+     * @throws [IllegalArgumentException] if the column with the given argument is not a frame column.
+     *
+     * @see [frameColumn]
+     * @see [ColumnsSelectionDsl.colGroup]
+     * @see [ColumnsSelectionDsl.valueCol]
+     * @see [ColumnsSelectionDsl.col]
+     *
+     *
+     *
+     * @param [index] The index of the value column.
+     * @throws [IndexOutOfBoundsException] if the index is out of bounds.
+     */
+    @Suppress("INAPPLICABLE_JVM_NAME")
+    @JvmName("frameColUnTyped")
+    public fun ColumnsSelectionDsl<*>.frameCol(index: Int): SingleColumn<DataFrame<*>> = frameCol<Any?>(index)
+
+    /**
+     * ## Frame Col
+     *
+     * Creates a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] (or [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]) for a frame column with the given argument which can be either
+     * an index ([Int]) or a reference to a column
+     * ([String], [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath], [KProperty], or [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor]; any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+     *
+     * This is a DSL-shorthand for [frameColumn][org.jetbrains.kotlinx.dataframe.api.frameColumn] and can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index). In addition, extra runtime checks are in place to ensure that the column
+     * you specify is actually a frame column.
+     * The function can also be called on [ColumnGroups][org.jetbrains.kotlinx.dataframe.ColumnGroupReference] to create
+     * an accessor for a frame column inside a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`<`[String][String]`>("frameColA") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`(SomeType::frameColB) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`(1) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { `[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`(0) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { `[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`<`[String][String]`>(0) }`
+     *
+     * To create a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for another kind of column, take a look at the functions
+     * [col][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.col],
+     * [colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup],
+     * and [valueCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.valueCol].
+     *
+     * @return A [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for the frame column with the given argument if possible, else a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn].
+     * @throws [IllegalStateException] if the column with the given argument does not exist.
+     * @throws [IllegalArgumentException] if the column with the given argument is not a frame column.
+     *
+     * @see [frameColumn]
+     * @see [ColumnsSelectionDsl.colGroup]
+     * @see [ColumnsSelectionDsl.valueCol]
+     * @see [ColumnsSelectionDsl.col]
+     *
+     *
+     *
+     * @param [index] The index of the value column.
+     * @throws [IndexOutOfBoundsException] if the index is out of bounds.
+     * @param [C] The type of the frame column.
+     */
+    public fun <C> ColumnsSelectionDsl<*>.frameCol(index: Int): SingleColumn<DataFrame<C>> =
+        asSingleColumn().frameCol<C>(index)
+
+    /**
+     * ## Frame Col
+     *
+     * Creates a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] (or [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]) for a frame column with the given argument which can be either
+     * an index ([Int]) or a reference to a column
+     * ([String], [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath], [KProperty], or [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor]; any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+     *
+     * This is a DSL-shorthand for [frameColumn][org.jetbrains.kotlinx.dataframe.api.frameColumn] and can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index). In addition, extra runtime checks are in place to ensure that the column
+     * you specify is actually a frame column.
+     * The function can also be called on [ColumnGroups][org.jetbrains.kotlinx.dataframe.ColumnGroupReference] to create
+     * an accessor for a frame column inside a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`<`[String][String]`>("frameColA") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`(SomeType::frameColB) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`(1) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`(0) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`<`[String][String]`>(0) }`
+     *
+     * To create a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for another kind of column, take a look at the functions
+     * [col][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.col],
+     * [colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup],
+     * and [valueCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.valueCol].
+     *
+     * @return A [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for the frame column with the given argument if possible, else a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn].
+     * @throws [IllegalStateException] if the column with the given argument does not exist.
+     * @throws [IllegalArgumentException] if the column with the given argument is not a frame column.
+     *
+     * @see [frameColumn]
+     * @see [ColumnsSelectionDsl.colGroup]
+     * @see [ColumnsSelectionDsl.valueCol]
+     * @see [ColumnsSelectionDsl.col]
+     *
+     *
+     *
+     * @param [index] The index of the value column.
+     * @throws [IndexOutOfBoundsException] if the index is out of bounds.
+     */
+    @Suppress("INAPPLICABLE_JVM_NAME")
+    @JvmName("frameColUnTyped")
+    public fun SingleColumn<DataRow<*>>.frameCol(index: Int): SingleColumn<DataFrame<*>> = frameCol<Any?>(index)
+
+    /**
+     * ## Frame Col
+     *
+     * Creates a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] (or [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]) for a frame column with the given argument which can be either
+     * an index ([Int]) or a reference to a column
+     * ([String], [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath], [KProperty], or [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor]; any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+     *
+     * This is a DSL-shorthand for [frameColumn][org.jetbrains.kotlinx.dataframe.api.frameColumn] and can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index). In addition, extra runtime checks are in place to ensure that the column
+     * you specify is actually a frame column.
+     * The function can also be called on [ColumnGroups][org.jetbrains.kotlinx.dataframe.ColumnGroupReference] to create
+     * an accessor for a frame column inside a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`<`[String][String]`>("frameColA") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`(SomeType::frameColB) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`(1) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`(0) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`<`[String][String]`>(0) }`
+     *
+     * To create a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for another kind of column, take a look at the functions
+     * [col][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.col],
+     * [colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup],
+     * and [valueCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.valueCol].
+     *
+     * @return A [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for the frame column with the given argument if possible, else a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn].
+     * @throws [IllegalStateException] if the column with the given argument does not exist.
+     * @throws [IllegalArgumentException] if the column with the given argument is not a frame column.
+     *
+     * @see [frameColumn]
+     * @see [ColumnsSelectionDsl.colGroup]
+     * @see [ColumnsSelectionDsl.valueCol]
+     * @see [ColumnsSelectionDsl.col]
+     *
+     *
+     *
+     * @param [index] The index of the value column.
+     * @throws [IndexOutOfBoundsException] if the index is out of bounds.
+     * @param [C] The type of the frame column.
+     */
+    public fun <C> SingleColumn<DataRow<*>>.frameCol(index: Int): SingleColumn<DataFrame<C>> =
+        this
+            .ensureIsColumnGroup()
+            .allColumnsInternal()
+            .getAt(index)
+            .cast<DataFrame<C>>()
+            .ensureIsFrameColumn()
+
+    /**
+     * ## Frame Col
+     *
+     * Creates a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] (or [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]) for a frame column with the given argument which can be either
+     * an index ([Int]) or a reference to a column
+     * ([String], [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath], [KProperty], or [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor]; any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+     *
+     * This is a DSL-shorthand for [frameColumn][org.jetbrains.kotlinx.dataframe.api.frameColumn] and can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index). In addition, extra runtime checks are in place to ensure that the column
+     * you specify is actually a frame column.
+     * The function can also be called on [ColumnGroups][org.jetbrains.kotlinx.dataframe.ColumnGroupReference] to create
+     * an accessor for a frame column inside a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`<`[String][String]`>("frameColA") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`(SomeType::frameColB) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`(1) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "myColumnGroup".`[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`(0) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "myColumnGroup".`[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`<`[String][String]`>(0) }`
+     *
+     * To create a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for another kind of column, take a look at the functions
+     * [col][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.col],
+     * [colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup],
+     * and [valueCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.valueCol].
+     *
+     * @return A [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for the frame column with the given argument if possible, else a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn].
+     * @throws [IllegalStateException] if the column with the given argument does not exist.
+     * @throws [IllegalArgumentException] if the column with the given argument is not a frame column.
+     *
+     * @see [frameColumn]
+     * @see [ColumnsSelectionDsl.colGroup]
+     * @see [ColumnsSelectionDsl.valueCol]
+     * @see [ColumnsSelectionDsl.col]
+     *
+     *
+     *
+     * @param [index] The index of the value column.
+     * @throws [IndexOutOfBoundsException] if the index is out of bounds.
+     */
+    @Suppress("INAPPLICABLE_JVM_NAME")
+    @JvmName("frameColUnTyped")
+    public fun String.frameCol(index: Int): SingleColumn<DataFrame<*>> = frameCol<Any?>(index)
+
+    /**
+     * ## Frame Col
+     *
+     * Creates a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] (or [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]) for a frame column with the given argument which can be either
+     * an index ([Int]) or a reference to a column
+     * ([String], [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath], [KProperty], or [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor]; any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+     *
+     * This is a DSL-shorthand for [frameColumn][org.jetbrains.kotlinx.dataframe.api.frameColumn] and can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index). In addition, extra runtime checks are in place to ensure that the column
+     * you specify is actually a frame column.
+     * The function can also be called on [ColumnGroups][org.jetbrains.kotlinx.dataframe.ColumnGroupReference] to create
+     * an accessor for a frame column inside a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`<`[String][String]`>("frameColA") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`(SomeType::frameColB) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`(1) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "myColumnGroup".`[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`(0) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "myColumnGroup".`[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`<`[String][String]`>(0) }`
+     *
+     * To create a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for another kind of column, take a look at the functions
+     * [col][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.col],
+     * [colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup],
+     * and [valueCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.valueCol].
+     *
+     * @return A [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for the frame column with the given argument if possible, else a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn].
+     * @throws [IllegalStateException] if the column with the given argument does not exist.
+     * @throws [IllegalArgumentException] if the column with the given argument is not a frame column.
+     *
+     * @see [frameColumn]
+     * @see [ColumnsSelectionDsl.colGroup]
+     * @see [ColumnsSelectionDsl.valueCol]
+     * @see [ColumnsSelectionDsl.col]
+     *
+     *
+     *
+     * @param [index] The index of the value column.
+     * @throws [IndexOutOfBoundsException] if the index is out of bounds.
+     * @param [C] The type of the frame column.
+     */
+    public fun <C> String.frameCol(index: Int): SingleColumn<DataFrame<C>> = columnGroup(this).frameCol<C>(index)
+
+    /**
+     * ## Frame Col
+     *
+     * Creates a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] (or [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]) for a frame column with the given argument which can be either
+     * an index ([Int]) or a reference to a column
+     * ([String], [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath], [KProperty], or [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor]; any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+     *
+     * This is a DSL-shorthand for [frameColumn][org.jetbrains.kotlinx.dataframe.api.frameColumn] and can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index). In addition, extra runtime checks are in place to ensure that the column
+     * you specify is actually a frame column.
+     * The function can also be called on [ColumnGroups][org.jetbrains.kotlinx.dataframe.ColumnGroupReference] to create
+     * an accessor for a frame column inside a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`<`[String][String]`>("frameColA") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`(SomeType::frameColB) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`(1) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { Type::myColumnGroup.`[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`(0) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { Type::myColumnGroup.`[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`<`[String][String]`>(0) }`
+     *
+     * To create a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for another kind of column, take a look at the functions
+     * [col][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.col],
+     * [colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup],
+     * and [valueCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.valueCol].
+     *
+     * @return A [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for the frame column with the given argument if possible, else a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn].
+     * @throws [IllegalStateException] if the column with the given argument does not exist.
+     * @throws [IllegalArgumentException] if the column with the given argument is not a frame column.
+     *
+     * @see [frameColumn]
+     * @see [ColumnsSelectionDsl.colGroup]
+     * @see [ColumnsSelectionDsl.valueCol]
+     * @see [ColumnsSelectionDsl.col]
+     *
+     *
+     *
+     * @param [index] The index of the value column.
+     * @throws [IndexOutOfBoundsException] if the index is out of bounds.
+     */
+    @Suppress("INAPPLICABLE_JVM_NAME")
+    @JvmName("frameColUnTyped")
+    public fun KProperty<*>.frameCol(index: Int): SingleColumn<DataFrame<*>> = frameCol<Any?>(index)
+
+    /**
+     * ## Frame Col
+     *
+     * Creates a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] (or [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]) for a frame column with the given argument which can be either
+     * an index ([Int]) or a reference to a column
+     * ([String], [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath], [KProperty], or [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor]; any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+     *
+     * This is a DSL-shorthand for [frameColumn][org.jetbrains.kotlinx.dataframe.api.frameColumn] and can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index). In addition, extra runtime checks are in place to ensure that the column
+     * you specify is actually a frame column.
+     * The function can also be called on [ColumnGroups][org.jetbrains.kotlinx.dataframe.ColumnGroupReference] to create
+     * an accessor for a frame column inside a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`<`[String][String]`>("frameColA") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`(SomeType::frameColB) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`(1) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { Type::myColumnGroup.`[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`(0) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { Type::myColumnGroup.`[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`<`[String][String]`>(0) }`
+     *
+     * To create a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for another kind of column, take a look at the functions
+     * [col][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.col],
+     * [colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup],
+     * and [valueCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.valueCol].
+     *
+     * @return A [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for the frame column with the given argument if possible, else a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn].
+     * @throws [IllegalStateException] if the column with the given argument does not exist.
+     * @throws [IllegalArgumentException] if the column with the given argument is not a frame column.
+     *
+     * @see [frameColumn]
+     * @see [ColumnsSelectionDsl.colGroup]
+     * @see [ColumnsSelectionDsl.valueCol]
+     * @see [ColumnsSelectionDsl.col]
+     *
+     *
+     *
+     * @param [index] The index of the value column.
+     * @throws [IndexOutOfBoundsException] if the index is out of bounds.
+     * @param [C] The type of the frame column.
+     */
+    public fun <C> KProperty<*>.frameCol(index: Int): SingleColumn<DataFrame<C>> = columnGroup(this).frameCol<C>(index)
+
+    /**
+     * ## Frame Col
+     *
+     * Creates a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] (or [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]) for a frame column with the given argument which can be either
+     * an index ([Int]) or a reference to a column
+     * ([String], [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath], [KProperty], or [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor]; any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+     *
+     * This is a DSL-shorthand for [frameColumn][org.jetbrains.kotlinx.dataframe.api.frameColumn] and can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index). In addition, extra runtime checks are in place to ensure that the column
+     * you specify is actually a frame column.
+     * The function can also be called on [ColumnGroups][org.jetbrains.kotlinx.dataframe.ColumnGroupReference] to create
+     * an accessor for a frame column inside a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`<`[String][String]`>("frameColA") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`(SomeType::frameColB) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`(1) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "pathTo"["myColumnGroup"].`[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`(0) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "pathTo"["myColumnGroup"].`[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`<`[String][String]`>(0) }`
+     *
+     * To create a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for another kind of column, take a look at the functions
+     * [col][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.col],
+     * [colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup],
+     * and [valueCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.valueCol].
+     *
+     * @return A [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for the frame column with the given argument if possible, else a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn].
+     * @throws [IllegalStateException] if the column with the given argument does not exist.
+     * @throws [IllegalArgumentException] if the column with the given argument is not a frame column.
+     *
+     * @see [frameColumn]
+     * @see [ColumnsSelectionDsl.colGroup]
+     * @see [ColumnsSelectionDsl.valueCol]
+     * @see [ColumnsSelectionDsl.col]
+     *
+     *
+     *
+     * @param [index] The index of the value column.
+     * @throws [IndexOutOfBoundsException] if the index is out of bounds.
+     */
+    @Suppress("INAPPLICABLE_JVM_NAME")
+    @JvmName("frameColUnTyped")
+    public fun ColumnPath.frameCol(index: Int): SingleColumn<DataFrame<*>> = frameCol<Any?>(index)
+
+    /**
+     * ## Frame Col
+     *
+     * Creates a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] (or [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]) for a frame column with the given argument which can be either
+     * an index ([Int]) or a reference to a column
+     * ([String], [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath], [KProperty], or [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor]; any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+     *
+     * This is a DSL-shorthand for [frameColumn][org.jetbrains.kotlinx.dataframe.api.frameColumn] and can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index). In addition, extra runtime checks are in place to ensure that the column
+     * you specify is actually a frame column.
+     * The function can also be called on [ColumnGroups][org.jetbrains.kotlinx.dataframe.ColumnGroupReference] to create
+     * an accessor for a frame column inside a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`<`[String][String]`>("frameColA") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`(SomeType::frameColB) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`(1) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "pathTo"["myColumnGroup"].`[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`(0) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "pathTo"["myColumnGroup"].`[frameCol][org.jetbrains.kotlinx.dataframe.api.FrameColColumnsSelectionDsl.frameCol]`<`[String][String]`>(0) }`
+     *
+     * To create a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for another kind of column, take a look at the functions
+     * [col][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.col],
+     * [colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup],
+     * and [valueCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.valueCol].
+     *
+     * @return A [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for the frame column with the given argument if possible, else a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn].
+     * @throws [IllegalStateException] if the column with the given argument does not exist.
+     * @throws [IllegalArgumentException] if the column with the given argument is not a frame column.
+     *
+     * @see [frameColumn]
+     * @see [ColumnsSelectionDsl.colGroup]
+     * @see [ColumnsSelectionDsl.valueCol]
+     * @see [ColumnsSelectionDsl.col]
+     *
+     *
+     *
+     * @param [index] The index of the value column.
+     * @throws [IndexOutOfBoundsException] if the index is out of bounds.
+     * @param [C] The type of the frame column.
+     */
+    public fun <C> ColumnPath.frameCol(index: Int): SingleColumn<DataFrame<C>> = columnGroup(this).frameCol<C>(index)
+
+    // endregion
+}
+
+/**
+ * Checks the validity of this [SingleColumn],
+ * by adding a check to see it's a [FrameColumn] (so, a [SingleColumn]<*>)
+ * and throwing an [IllegalArgumentException] if it's not.
+ */
+internal fun <C> SingleColumn<DataFrame<C>>.ensureIsFrameColumn(): SingleColumn<DataFrame<C>> =
+    onResolve { col: ColumnWithPath<*>? ->
+        require(col?.isFrameColumn() != false) {
+            "Column at ${col?.path} is not a FrameColumn, but a ${col?.kind()}."
+        }
+    }
+
+/** Checks the validity of this [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn],
+ * by adding a check to see it's a [FrameColumn][org.jetbrains.kotlinx.dataframe.columns.FrameColumn] (so, a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]<*>)
+ * and throwing an [IllegalArgumentException] if it's not. */
+internal fun <C> ColumnAccessor<DataFrame<C>>.ensureIsFrameColumn(): ColumnAccessor<DataFrame<C>> =
+    onResolve { col: ColumnWithPath<*>? ->
+        require(col?.isFrameColumn() != false) {
+            "Column at ${col?.path} is not a FrameColumn, but a ${col?.kind()}."
+        }
+    }
+
+// endregion
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/frameCols.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/frameCols.kt
new file mode 100644
index 000000000..74a91151f
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/frameCols.kt
@@ -0,0 +1,370 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import org.jetbrains.kotlinx.dataframe.AnyFrame
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.DataRow
+import org.jetbrains.kotlinx.dataframe.Predicate
+import org.jetbrains.kotlinx.dataframe.annotations.Interpretable
+import org.jetbrains.kotlinx.dataframe.columns.ColumnPath
+import org.jetbrains.kotlinx.dataframe.columns.ColumnReference
+import org.jetbrains.kotlinx.dataframe.columns.ColumnSet
+import org.jetbrains.kotlinx.dataframe.columns.ColumnsResolver
+import org.jetbrains.kotlinx.dataframe.columns.FrameColumn
+import org.jetbrains.kotlinx.dataframe.columns.SingleColumn
+import org.jetbrains.kotlinx.dataframe.documentation.AccessApi
+import org.jetbrains.kotlinx.dataframe.impl.columns.TransformableColumnSet
+import kotlin.reflect.KProperty
+
+// region ColumnsSelectionDsl
+
+/**
+ * ## Frame Columns [Columns Selection DSL][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl]
+ *
+ * See [Grammar] for all functions in this interface.
+ */
+public interface FrameColsColumnsSelectionDsl {
+
+    /**
+     * ## Frame Cols Grammar
+     *
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * [(What is this notation?)][org.jetbrains.kotlinx.dataframe.documentation.DslGrammar]
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  ### Definitions:
+     *  `columnSet: `[`ColumnSet`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]`<*>`
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  `columnGroup: `[`SingleColumn`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]`<`[`DataRow`][org.jetbrains.kotlinx.dataframe.DataRow]`<*>> | `[`String`][String]`  |  `[`KProperty`][kotlin.reflect.KProperty]`<* | `[`DataRow`][org.jetbrains.kotlinx.dataframe.DataRow]`<*>> | `[`ColumnPath`][org.jetbrains.kotlinx.dataframe.columns.ColumnPath]
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  `condition: `[`ColumnFilter`][org.jetbrains.kotlinx.dataframe.ColumnFilter]
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  ### What can be called directly in the [Columns Selection DSL][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl]:
+     *
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  [**`frameCols`**][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroups]`  [  `**`{ `**[`condition`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ConditionDef]**` }`**` ]`
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  ### What can be called on a [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]:
+     *
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  [`columnSet`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ColumnSetDef]
+     *
+     *  &nbsp;&nbsp;&nbsp;&nbsp;__`.`__[**`frameCols`**][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroups]`  [  `**`{ `**[`condition`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ConditionDef]**` }`**` ]`
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  ### What can be called on a [Column Group (reference)][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ColumnGroupDef]:
+     *
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  [`columnGroup`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ColumnGroupDef]
+     *
+     *  &nbsp;&nbsp;&nbsp;&nbsp;__`.`__[**`frameCols`**][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroups]`  [  `**`{ `**[`condition`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ConditionDef]**` }`**` ]`
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     */
+    public interface Grammar {
+
+        /** [**`frameCols`**][ColumnsSelectionDsl.colGroups] */
+        public interface PlainDslName
+
+        /** __`.`__[**`frameCols`**][ColumnsSelectionDsl.colGroups] */
+        public interface ColumnSetName
+
+        /** __`.`__[**`frameCols`**][ColumnsSelectionDsl.colGroups] */
+        public interface ColumnGroupName
+    }
+
+    /**
+     * ## Frame Columns
+     * Creates a subset of columns from [this] that are [FrameColumns][FrameColumn].
+     *
+     * You can optionally use a [filter] to only include certain columns.
+     * [frameCols] can be called using any of the supported [APIs][AccessApi] (+ [ColumnPath]).
+     *
+     * This function operates solely on columns at the top-level.
+     *
+     * ### Check out: [Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][DataFrame.select]`  {  `[frameCols][SingleColumn.frameCols]` { it.`[name][ColumnReference.name]`.`[startsWith][String.startsWith]`("my") } }`
+     *
+     * `df.`[select][DataFrame.select]`  {  `[colsAtAnyDepth][ColumnsSelectionDsl.colsAtAnyDepth]`().`[frameCols][SingleColumn.frameCols]`() }`
+     *
+     * `df.`[select][DataFrame.select]` { "myColGroup".`[frameCols][String.frameCols]`() }`
+     *
+     * #### Examples for this overload:
+     *
+     *
+     *
+     * @param [filter] An optional [predicate][Predicate] to filter the frame columns by.
+     * @return A [ColumnSet] of [FrameColumns][FrameColumn].
+     * @see [ColumnsSelectionDsl.colsOfKind]
+     * @see [ColumnsSelectionDsl.valueCols]
+     * @see [ColumnsSelectionDsl.colGroups]
+     * @see [ColumnsSelectionDsl.cols]
+     */
+    private interface CommonFrameColsDocs {
+
+        /** Example argument */
+        interface ExampleArg
+    }
+
+    /**
+     * ## Frame Columns
+     * Creates a subset of columns from [this] that are [FrameColumns][org.jetbrains.kotlinx.dataframe.columns.FrameColumn].
+     *
+     * You can optionally use a [filter] to only include certain columns.
+     * [frameCols][org.jetbrains.kotlinx.dataframe.api.FrameColsColumnsSelectionDsl.frameCols] can be called using any of the supported [APIs][org.jetbrains.kotlinx.dataframe.documentation.AccessApi] (+ [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath]).
+     *
+     * This function operates solely on columns at the top-level.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.FrameColsColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[frameCols][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.frameCols]` { it.`[name][org.jetbrains.kotlinx.dataframe.columns.ColumnReference.name]`.`[startsWith][String.startsWith]`("my") } }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsAtAnyDepth][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsAtAnyDepth]`().`[frameCols][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.frameCols]`() }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "myColGroup".`[frameCols][kotlin.String.frameCols]`() }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][DataFrame.select]`  {  `[cols][ColumnsSelectionDsl.cols]` { it.`[name][ColumnReference.name]`.`[startsWith][String.startsWith]`("my") }.`[frameCols][ColumnSet.frameCols]`() }`
+     *
+     * `// NOTE: This can be shortened to just:`
+     *
+     * `df.`[select][DataFrame.select]`  {  `[frameCols][ColumnsSelectionDsl.frameCols]` { it.`[name][ColumnReference.name]`.`[startsWith][String.startsWith]`("my") } }`
+     *
+     * @param [filter] An optional [predicate][org.jetbrains.kotlinx.dataframe.Predicate] to filter the frame columns by.
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] of [FrameColumns][org.jetbrains.kotlinx.dataframe.columns.FrameColumn].
+     * @see [ColumnsSelectionDsl.colsOfKind]
+     * @see [ColumnsSelectionDsl.valueCols]
+     * @see [ColumnsSelectionDsl.colGroups]
+     * @see [ColumnsSelectionDsl.cols]
+     */
+    @Interpretable("FrameCols0")
+    public fun ColumnSet<*>.frameCols(
+        filter: Predicate<FrameColumn<*>> = { true },
+    ): TransformableColumnSet<DataFrame<*>> = frameColumnsInternal(filter)
+
+    /**
+     * ## Frame Columns
+     * Creates a subset of columns from [this] that are [FrameColumns][org.jetbrains.kotlinx.dataframe.columns.FrameColumn].
+     *
+     * You can optionally use a [filter] to only include certain columns.
+     * [frameCols][org.jetbrains.kotlinx.dataframe.api.FrameColsColumnsSelectionDsl.frameCols] can be called using any of the supported [APIs][org.jetbrains.kotlinx.dataframe.documentation.AccessApi] (+ [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath]).
+     *
+     * This function operates solely on columns at the top-level.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.FrameColsColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[frameCols][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.frameCols]` { it.`[name][org.jetbrains.kotlinx.dataframe.columns.ColumnReference.name]`.`[startsWith][String.startsWith]`("my") } }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsAtAnyDepth][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsAtAnyDepth]`().`[frameCols][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.frameCols]`() }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "myColGroup".`[frameCols][kotlin.String.frameCols]`() }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][DataFrame.select]`  {  `[frameCols][ColumnsSelectionDsl.frameCols]`() }`
+     *
+     * `df.`[select][DataFrame.select]`  {  `[frameCols][ColumnsSelectionDsl.frameCols]` { it.`[name][ColumnReference.name]`.`[startsWith][String.startsWith]`("my") } }`
+     *
+     * @param [filter] An optional [predicate][org.jetbrains.kotlinx.dataframe.Predicate] to filter the frame columns by.
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] of [FrameColumns][org.jetbrains.kotlinx.dataframe.columns.FrameColumn].
+     * @see [ColumnsSelectionDsl.colsOfKind]
+     * @see [ColumnsSelectionDsl.valueCols]
+     * @see [ColumnsSelectionDsl.colGroups]
+     * @see [ColumnsSelectionDsl.cols]
+     */
+    public fun ColumnsSelectionDsl<*>.frameCols(
+        filter: Predicate<FrameColumn<*>> = { true },
+    ): TransformableColumnSet<DataFrame<*>> = asSingleColumn().frameColumnsInternal(filter)
+
+    /**
+     * ## Frame Columns
+     * Creates a subset of columns from [this] that are [FrameColumns][org.jetbrains.kotlinx.dataframe.columns.FrameColumn].
+     *
+     * You can optionally use a [filter] to only include certain columns.
+     * [frameCols][org.jetbrains.kotlinx.dataframe.api.FrameColsColumnsSelectionDsl.frameCols] can be called using any of the supported [APIs][org.jetbrains.kotlinx.dataframe.documentation.AccessApi] (+ [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath]).
+     *
+     * This function operates solely on columns at the top-level.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.FrameColsColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[frameCols][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.frameCols]` { it.`[name][org.jetbrains.kotlinx.dataframe.columns.ColumnReference.name]`.`[startsWith][String.startsWith]`("my") } }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsAtAnyDepth][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsAtAnyDepth]`().`[frameCols][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.frameCols]`() }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "myColGroup".`[frameCols][kotlin.String.frameCols]`() }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][DataFrame.select]` { myColGroup.`[frameCols][SingleColumn.frameCols]`() }`
+     *
+     * `df.`[select][DataFrame.select]` { myColGroup.`[frameCols][SingleColumn.frameCols]` { it.`[name][ColumnReference.name]`.`[startsWith][String.startsWith]`("my") } }`
+     *
+     * @param [filter] An optional [predicate][org.jetbrains.kotlinx.dataframe.Predicate] to filter the frame columns by.
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] of [FrameColumns][org.jetbrains.kotlinx.dataframe.columns.FrameColumn].
+     * @see [ColumnsSelectionDsl.colsOfKind]
+     * @see [ColumnsSelectionDsl.valueCols]
+     * @see [ColumnsSelectionDsl.colGroups]
+     * @see [ColumnsSelectionDsl.cols]
+     */
+    public fun SingleColumn<DataRow<*>>.frameCols(
+        filter: Predicate<FrameColumn<*>> = { true },
+    ): TransformableColumnSet<DataFrame<*>> = this.ensureIsColumnGroup().frameColumnsInternal(filter)
+
+    /**
+     * ## Frame Columns
+     * Creates a subset of columns from [this] that are [FrameColumns][org.jetbrains.kotlinx.dataframe.columns.FrameColumn].
+     *
+     * You can optionally use a [filter] to only include certain columns.
+     * [frameCols][org.jetbrains.kotlinx.dataframe.api.FrameColsColumnsSelectionDsl.frameCols] can be called using any of the supported [APIs][org.jetbrains.kotlinx.dataframe.documentation.AccessApi] (+ [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath]).
+     *
+     * This function operates solely on columns at the top-level.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.FrameColsColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[frameCols][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.frameCols]` { it.`[name][org.jetbrains.kotlinx.dataframe.columns.ColumnReference.name]`.`[startsWith][String.startsWith]`("my") } }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsAtAnyDepth][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsAtAnyDepth]`().`[frameCols][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.frameCols]`() }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "myColGroup".`[frameCols][kotlin.String.frameCols]`() }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][DataFrame.select]` { "myColGroup".`[frameCols][String.frameCols]` { it.`[name][ColumnReference.name]`.`[startsWith][String.startsWith]`("my") } }`
+     *
+     * `df.`[select][DataFrame.select]` { "myColGroup".`[frameCols][String.frameCols]`() }`
+     *
+     * @param [filter] An optional [predicate][org.jetbrains.kotlinx.dataframe.Predicate] to filter the frame columns by.
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] of [FrameColumns][org.jetbrains.kotlinx.dataframe.columns.FrameColumn].
+     * @see [ColumnsSelectionDsl.colsOfKind]
+     * @see [ColumnsSelectionDsl.valueCols]
+     * @see [ColumnsSelectionDsl.colGroups]
+     * @see [ColumnsSelectionDsl.cols]
+     */
+    public fun String.frameCols(filter: Predicate<FrameColumn<*>> = { true }): TransformableColumnSet<DataFrame<*>> =
+        columnGroup(this).frameCols(filter)
+
+    /**
+     * ## Frame Columns
+     * Creates a subset of columns from [this] that are [FrameColumns][org.jetbrains.kotlinx.dataframe.columns.FrameColumn].
+     *
+     * You can optionally use a [filter] to only include certain columns.
+     * [frameCols][org.jetbrains.kotlinx.dataframe.api.FrameColsColumnsSelectionDsl.frameCols] can be called using any of the supported [APIs][org.jetbrains.kotlinx.dataframe.documentation.AccessApi] (+ [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath]).
+     *
+     * This function operates solely on columns at the top-level.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.FrameColsColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[frameCols][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.frameCols]` { it.`[name][org.jetbrains.kotlinx.dataframe.columns.ColumnReference.name]`.`[startsWith][String.startsWith]`("my") } }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsAtAnyDepth][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsAtAnyDepth]`().`[frameCols][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.frameCols]`() }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "myColGroup".`[frameCols][kotlin.String.frameCols]`() }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][DataFrame.select]`  {  `[colGroup][ColumnsSelectionDsl.colGroup]`(Type::myColGroup).`[frameCols][SingleColumn.frameCols]` { it.`[name][ColumnReference.name]`.`[startsWith][String.startsWith]`("my") } }`
+     *
+     * `df.`[select][DataFrame.select]` { Type::myColGroup.`[frameCols][SingleColumn.frameCols]`() }`
+     *
+     * `df.`[select][DataFrame.select]` { DataSchemaType::myColGroup.`[frameCols][KProperty.frameCols]`() }`
+     *
+     * @param [filter] An optional [predicate][org.jetbrains.kotlinx.dataframe.Predicate] to filter the frame columns by.
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] of [FrameColumns][org.jetbrains.kotlinx.dataframe.columns.FrameColumn].
+     * @see [ColumnsSelectionDsl.colsOfKind]
+     * @see [ColumnsSelectionDsl.valueCols]
+     * @see [ColumnsSelectionDsl.colGroups]
+     * @see [ColumnsSelectionDsl.cols]
+     */
+    public fun KProperty<*>.frameCols(
+        filter: Predicate<FrameColumn<*>> = { true },
+    ): TransformableColumnSet<DataFrame<*>> = columnGroup(this).frameCols(filter)
+
+    /**
+     * ## Frame Columns
+     * Creates a subset of columns from [this] that are [FrameColumns][org.jetbrains.kotlinx.dataframe.columns.FrameColumn].
+     *
+     * You can optionally use a [filter] to only include certain columns.
+     * [frameCols][org.jetbrains.kotlinx.dataframe.api.FrameColsColumnsSelectionDsl.frameCols] can be called using any of the supported [APIs][org.jetbrains.kotlinx.dataframe.documentation.AccessApi] (+ [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath]).
+     *
+     * This function operates solely on columns at the top-level.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.FrameColsColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[frameCols][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.frameCols]` { it.`[name][org.jetbrains.kotlinx.dataframe.columns.ColumnReference.name]`.`[startsWith][String.startsWith]`("my") } }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsAtAnyDepth][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsAtAnyDepth]`().`[frameCols][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.frameCols]`() }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "myColGroup".`[frameCols][kotlin.String.frameCols]`() }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][DataFrame.select]` { "pathTo"["myGroupCol"].`[frameCols][ColumnPath.frameCols]`() }`
+     *
+     * @param [filter] An optional [predicate][org.jetbrains.kotlinx.dataframe.Predicate] to filter the frame columns by.
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] of [FrameColumns][org.jetbrains.kotlinx.dataframe.columns.FrameColumn].
+     * @see [ColumnsSelectionDsl.colsOfKind]
+     * @see [ColumnsSelectionDsl.valueCols]
+     * @see [ColumnsSelectionDsl.colGroups]
+     * @see [ColumnsSelectionDsl.cols]
+     */
+    public fun ColumnPath.frameCols(
+        filter: Predicate<FrameColumn<*>> = { true },
+    ): TransformableColumnSet<DataFrame<*>> = columnGroup(this).frameCols(filter)
+}
+
+/**
+ * Returns a TransformableColumnSet containing the frame columns that satisfy the given filter.
+ *
+ * @param filter The filter function to apply on each frame column. Must accept a FrameColumn object and return a Boolean.
+ * @return A [TransformableColumnSet] containing the frame columns that satisfy the filter.
+ */
+@Suppress("UNCHECKED_CAST")
+internal fun ColumnsResolver<*>.frameColumnsInternal(
+    filter: (FrameColumn<*>) -> Boolean,
+): TransformableColumnSet<AnyFrame> =
+    colsInternal { it.isFrameColumn() && filter(it.asFrameColumn()) } as TransformableColumnSet<AnyFrame>
+
+// endregion
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/frames.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/frames.kt
new file mode 100644
index 000000000..7f82f8fc5
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/frames.kt
@@ -0,0 +1,16 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.DataRow
+
+// region Pivot
+
+public fun <T> Pivot<T>.frames(): DataRow<T> = aggregate { this }
+
+// endregion
+
+// region PivotGroupBy
+
+public fun <T> PivotGroupBy<T>.frames(): DataFrame<T> = aggregate { this }
+
+// endregion
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/gather.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/gather.kt
new file mode 100644
index 000000000..52446cbd1
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/gather.kt
@@ -0,0 +1,106 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import org.jetbrains.kotlinx.dataframe.ColumnsSelector
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.RowValueFilter
+import org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor
+import org.jetbrains.kotlinx.dataframe.columns.ColumnReference
+import org.jetbrains.kotlinx.dataframe.columns.toColumnSet
+import org.jetbrains.kotlinx.dataframe.impl.api.gatherImpl
+import org.jetbrains.kotlinx.dataframe.impl.columnName
+import kotlin.reflect.KProperty
+import kotlin.reflect.KType
+import kotlin.reflect.typeOf
+
+// region gather
+
+public fun <T, C> DataFrame<T>.gather(selector: ColumnsSelector<T, C>): Gather<T, C, String, C> =
+    Gather(
+        df = this,
+        columns = selector,
+        filter = null,
+        keyType = typeOf<String>(),
+        keyTransform = { it },
+        valueTransform = null,
+    )
+
+public fun <T> DataFrame<T>.gather(vararg columns: String): Gather<T, Any?, String, Any?> =
+    gather { columns.toColumnSet() }
+
+public fun <T, C> DataFrame<T>.gather(vararg columns: ColumnReference<C>): Gather<T, C, String, C> =
+    gather { columns.toColumnSet() }
+
+public fun <T, C> DataFrame<T>.gather(vararg columns: KProperty<C>): Gather<T, C, String, C> =
+    gather { columns.toColumnSet() }
+
+// endregion
+
+public fun <T, C, K, R> Gather<T, C, K, R>.where(filter: RowValueFilter<T, C>): Gather<T, C, K, R> =
+    copy(filter = this.filter and filter)
+
+public fun <T, C, K, R> Gather<T, C?, K, R>.notNull(): Gather<T, C, K, R> = where { it != null } as Gather<T, C, K, R>
+
+public fun <T, C, K, R> Gather<T, C, K, R>.explodeLists(): Gather<T, C, K, R> = copy(explode = true)
+
+public inline fun <T, C, reified K, R> Gather<T, C, *, R>.mapKeys(
+    noinline transform: (String) -> K,
+): Gather<T, C, K, R> =
+    copy(keyTransform = transform as ((String) -> Nothing), keyType = typeOf<K>()) as Gather<T, C, K, R>
+
+public fun <T, C, K, R> Gather<T, C, K, *>.mapValues(transform: (C) -> R): Gather<T, C, K, R> =
+    copy(valueTransform = transform as ((C) -> Nothing)) as Gather<T, C, K, R>
+
+public data class Gather<T, C, K, R>(
+    internal val df: DataFrame<T>,
+    internal val columns: ColumnsSelector<T, C>,
+    internal val filter: RowValueFilter<T, C>? = null,
+    internal val keyType: KType? = null,
+    internal val keyTransform: ((String) -> K),
+    internal val valueTransform: ((C) -> R)? = null,
+    internal val explode: Boolean = false,
+) {
+    public fun <P> cast(): Gather<T, P, K, P> {
+        // TODO: introduce GatherWithTransform to avoid this error
+        require(valueTransform == null) { "Cast is not allowed to be called after `mapValues`" }
+        return this as Gather<T, P, K, P>
+    }
+}
+
+// region into
+
+public fun <T, C, K, R> Gather<T, C, K, R>.into(keyColumn: String, valueColumn: String): DataFrame<T> =
+    gatherImpl(keyColumn, valueColumn)
+
+public fun <T, C, K, R> Gather<T, C, K, R>.into(
+    keyColumn: ColumnAccessor<K>,
+    valueColumn: ColumnAccessor<R>,
+): DataFrame<T> = into(keyColumn.name(), valueColumn.name)
+
+public fun <T, C, K, R> Gather<T, C, K, R>.into(keyColumn: KProperty<K>, valueColumn: KProperty<R>): DataFrame<T> =
+    into(keyColumn.columnName, valueColumn.columnName)
+
+// endregion
+
+// region keysInto
+
+public fun <T, C, K, R> Gather<T, C, K, R>.keysInto(keyColumn: String): DataFrame<T> = gatherImpl(keyColumn, null)
+
+public fun <T, C, K, R> Gather<T, C, K, R>.keysInto(keyColumn: ColumnAccessor<K>): DataFrame<T> =
+    keysInto(keyColumn.name())
+
+public fun <T, C, K, R> Gather<T, C, K, R>.keysInto(keyColumn: KProperty<K>): DataFrame<T> =
+    keysInto(keyColumn.columnName)
+
+// endregion
+
+// region valuesInto
+
+public fun <T, C, K, R> Gather<T, C, K, R>.valuesInto(valueColumn: String): DataFrame<T> = gatherImpl(null, valueColumn)
+
+public fun <T, C, K, R> Gather<T, C, K, R>.valuesInto(valueColumn: ColumnAccessor<K>): DataFrame<T> =
+    valuesInto(valueColumn.name())
+
+public fun <T, C, K, R> Gather<T, C, K, R>.valuesInto(valueColumn: KProperty<K>): DataFrame<T> =
+    valuesInto(valueColumn.columnName)
+
+// endregion
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/generateCode.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/generateCode.kt
new file mode 100644
index 000000000..a51e0815a
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/generateCode.kt
@@ -0,0 +1,87 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import org.jetbrains.dataframe.impl.codeGen.CodeGenerator
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.codeGen.MarkerVisibility
+import org.jetbrains.kotlinx.dataframe.codeGen.NameNormalizer
+import org.jetbrains.kotlinx.dataframe.impl.codeGen.from
+
+public inline fun <reified T> DataFrame<T>.generateCode(
+    fields: Boolean = true,
+    extensionProperties: Boolean = true,
+): CodeString {
+    val name = markerName<T>()
+    return generateCode(name, fields, extensionProperties)
+}
+
+public fun <T> DataFrame<T>.generateCode(
+    markerName: String,
+    fields: Boolean = true,
+    extensionProperties: Boolean = true,
+    visibility: MarkerVisibility = MarkerVisibility.IMPLICIT_PUBLIC,
+): CodeString {
+    val codeGen = CodeGenerator.create()
+    return codeGen.generate(
+        schema = schema(),
+        name = markerName,
+        fields = fields,
+        extensionProperties = extensionProperties,
+        isOpen = true,
+        visibility = visibility,
+    ).code.declarations.toCodeString()
+}
+
+public inline fun <reified T> DataFrame<T>.generateInterfaces(): CodeString =
+    generateCode(
+        fields = true,
+        extensionProperties = false,
+    )
+
+public inline fun <reified T> DataFrame<T>.generateDataClasses(
+    markerName: String? = null,
+    extensionProperties: Boolean = false,
+    visibility: MarkerVisibility = MarkerVisibility.IMPLICIT_PUBLIC,
+    useFqNames: Boolean = false,
+    nameNormalizer: NameNormalizer = NameNormalizer.default,
+): CodeString {
+    val name = markerName ?: markerName<T>()
+    val codeGen = CodeGenerator.create(useFqNames)
+    return codeGen.generate(
+        schema = schema(),
+        name = name,
+        fields = true,
+        extensionProperties = extensionProperties,
+        isOpen = false,
+        visibility = visibility,
+        asDataClass = true,
+        fieldNameNormalizer = nameNormalizer,
+    ).code.declarations.toCodeString()
+}
+
+@PublishedApi
+internal inline fun <reified T> markerName(): String =
+    if (T::class.isAbstract) {
+        T::class.simpleName!!
+    } else {
+        "DataEntry"
+    }
+
+public fun <T> DataFrame<T>.generateInterfaces(markerName: String): CodeString =
+    generateCode(
+        markerName = markerName,
+        fields = true,
+        extensionProperties = false,
+    )
+
+/**
+ * Converts delimited 'my_name', 'my name', etc., String to camelCase 'myName'
+ */
+public val NameNormalizer.Companion.default: NameNormalizer get() = NameNormalizer.from(setOf('\t', ' ', '_'))
+
+@JvmInline
+public value class CodeString(public val value: String) {
+    override fun toString(): String = value
+}
+
+@PublishedApi
+internal fun String.toCodeString(): CodeString = CodeString(this)
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/group.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/group.kt
new file mode 100644
index 000000000..9bd4c1602
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/group.kt
@@ -0,0 +1,58 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import org.jetbrains.kotlinx.dataframe.AnyColumnGroupAccessor
+import org.jetbrains.kotlinx.dataframe.AnyColumnReference
+import org.jetbrains.kotlinx.dataframe.ColumnsSelector
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.annotations.Interpretable
+import org.jetbrains.kotlinx.dataframe.annotations.Refine
+import org.jetbrains.kotlinx.dataframe.columns.ColumnWithPath
+import org.jetbrains.kotlinx.dataframe.columns.toColumnSet
+import org.jetbrains.kotlinx.dataframe.impl.columnName
+import kotlin.experimental.ExperimentalTypeInference
+import kotlin.reflect.KProperty
+
+// region DataFrame
+
+@Interpretable("Group0")
+public fun <T, C> DataFrame<T>.group(columns: ColumnsSelector<T, C>): GroupClause<T, C> = GroupClause(this, columns)
+
+public fun <T> DataFrame<T>.group(vararg columns: String): GroupClause<T, Any?> = group { columns.toColumnSet() }
+
+public fun <T> DataFrame<T>.group(vararg columns: AnyColumnReference): GroupClause<T, Any?> =
+    group { columns.toColumnSet() }
+
+public fun <T> DataFrame<T>.group(vararg columns: KProperty<*>): GroupClause<T, Any?> = group { columns.toColumnSet() }
+
+// endregion
+
+// region GroupClause
+
+public class GroupClause<T, C>(internal val df: DataFrame<T>, internal val columns: ColumnsSelector<T, C>) {
+    override fun toString(): String = "GroupClause(df=$df, columns=$columns)"
+}
+
+// region into
+
+@JvmName("intoString")
+@OverloadResolutionByLambdaReturnType
+@OptIn(ExperimentalTypeInference::class)
+public fun <T, C> GroupClause<T, C>.into(column: ColumnsSelectionDsl<T>.(ColumnWithPath<C>) -> String): DataFrame<T> =
+    df.move(columns).under { column(it).toColumnAccessor() }
+
+@JvmName("intoColumn")
+public fun <T, C> GroupClause<T, C>.into(
+    column: ColumnsSelectionDsl<T>.(ColumnWithPath<C>) -> AnyColumnReference,
+): DataFrame<T> = df.move(columns).under(column)
+
+@Refine
+@Interpretable("Into0")
+public fun <T, C> GroupClause<T, C>.into(column: String): DataFrame<T> = into(columnGroup().named(column))
+
+public fun <T, C> GroupClause<T, C>.into(column: AnyColumnGroupAccessor): DataFrame<T> = df.move(columns).under(column)
+
+public fun <T, C> GroupClause<T, C>.into(column: KProperty<*>): DataFrame<T> = into(column.columnName)
+
+// endregion
+
+// endregion
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/groupBy.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/groupBy.kt
new file mode 100644
index 000000000..4067b6b4f
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/groupBy.kt
@@ -0,0 +1,107 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import org.jetbrains.kotlinx.dataframe.AnyColumnReference
+import org.jetbrains.kotlinx.dataframe.AnyFrame
+import org.jetbrains.kotlinx.dataframe.ColumnsSelector
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.DataRow
+import org.jetbrains.kotlinx.dataframe.Selector
+import org.jetbrains.kotlinx.dataframe.aggregation.Aggregatable
+import org.jetbrains.kotlinx.dataframe.annotations.Interpretable
+import org.jetbrains.kotlinx.dataframe.annotations.Refine
+import org.jetbrains.kotlinx.dataframe.columns.FrameColumn
+import org.jetbrains.kotlinx.dataframe.columns.toColumnSet
+import org.jetbrains.kotlinx.dataframe.impl.aggregation.PivotImpl
+import org.jetbrains.kotlinx.dataframe.impl.api.getPivotColumnPaths
+import org.jetbrains.kotlinx.dataframe.impl.api.groupByImpl
+import kotlin.reflect.KProperty
+
+// region DataFrame
+
+/**
+ *
+ * @param cols key columns; Column for grouping can be created inplace
+ *
+ * `df.groupBy { expr("columnName") { "someColumn"<Int>() + 15 } }`
+ *
+ * is equivalent to
+ *
+ * `df.add("columnName") { "someColumn"<Int>() + 15 }.groupBy("columnName")`
+ */
+@Refine
+@Interpretable("DataFrameGroupBy")
+public fun <T> DataFrame<T>.groupBy(moveToTop: Boolean = true, cols: ColumnsSelector<T, *>): GroupBy<T, T> =
+    groupByImpl(moveToTop, cols)
+
+public fun <T> DataFrame<T>.groupBy(vararg cols: KProperty<*>): GroupBy<T, T> = groupBy { cols.toColumnSet() }
+
+public fun <T> DataFrame<T>.groupBy(vararg cols: String): GroupBy<T, T> = groupBy { cols.toColumnSet() }
+
+public fun <T> DataFrame<T>.groupBy(vararg cols: AnyColumnReference, moveToTop: Boolean = true): GroupBy<T, T> =
+    groupBy(moveToTop) { cols.toColumnSet() }
+
+// endregion
+
+// region Pivot
+
+public fun <T> Pivot<T>.groupBy(moveToTop: Boolean = true, columns: ColumnsSelector<T, *>): PivotGroupBy<T> =
+    (this as PivotImpl<T>).toGroupedPivot(moveToTop, columns)
+
+public fun <T> Pivot<T>.groupBy(vararg columns: AnyColumnReference): PivotGroupBy<T> = groupBy { columns.toColumnSet() }
+
+public fun <T> Pivot<T>.groupBy(vararg columns: String): PivotGroupBy<T> = groupBy { columns.toColumnSet() }
+
+public fun <T> Pivot<T>.groupBy(vararg columns: KProperty<*>): PivotGroupBy<T> = groupBy { columns.toColumnSet() }
+
+public fun <T> Pivot<T>.groupByOther(): PivotGroupBy<T> {
+    val impl = this as PivotImpl<T>
+    val pivotColumns = df.getPivotColumnPaths(columns).toColumnSet()
+    return impl.toGroupedPivot(moveToTop = false) { allExcept(pivotColumns) }
+}
+
+// endregion
+
+public typealias GroupedRowSelector<T, G, R> = GroupedDataRow<T, G>.(GroupedDataRow<T, G>) -> R
+
+public typealias GroupedRowFilter<T, G> = GroupedRowSelector<T, G, Boolean>
+
+public interface GroupedDataRow<out T, out G> : DataRow<T> {
+
+    public fun group(): DataFrame<G>
+}
+
+public val <T, G> GroupedDataRow<T, G>.group: DataFrame<G> get() = group()
+
+public data class GroupWithKey<T, G>(val key: DataRow<T>, val group: DataFrame<G>)
+
+public interface GroupBy<out T, out G> : Grouped<G> {
+
+    public val groups: FrameColumn<G>
+
+    public val keys: DataFrame<T>
+
+    public fun <R> updateGroups(transform: Selector<DataFrame<G>, DataFrame<R>>): GroupBy<T, R>
+
+    public fun filter(predicate: GroupedRowFilter<T, G>): GroupBy<T, G>
+
+    @Refine
+    @Interpretable("GroupByToDataFrame")
+    public fun toDataFrame(groupedColumnName: String? = null): DataFrame<T>
+
+    public data class Entry<T, G>(val key: DataRow<T>, val group: DataFrame<G>)
+
+    public companion object {
+        internal val groupedColumnAccessor = column<AnyFrame>("group")
+    }
+}
+
+public interface Grouped<out T> : Aggregatable<T>
+
+public class ReducedGroupBy<T, G>(
+    @PublishedApi internal val groupBy: GroupBy<T, G>,
+    @PublishedApi internal val reducer: Selector<DataFrame<G>, DataRow<G>?>,
+) {
+    override fun toString(): String = "ReducedGroupBy(groupBy=$groupBy, reducer=$reducer)"
+}
+
+internal fun <T, G> GroupBy<T, G>.reduce(reducer: Selector<DataFrame<G>, DataRow<G>?>) = ReducedGroupBy(this, reducer)
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/head.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/head.kt
new file mode 100644
index 000000000..3c23f050a
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/head.kt
@@ -0,0 +1,9 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import org.jetbrains.kotlinx.dataframe.DataFrame
+
+// region DataFrame
+
+public fun <T> DataFrame<T>.head(numRows: Int = 5): DataFrame<T> = take(numRows)
+
+// endregion
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/implode.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/implode.kt
new file mode 100644
index 000000000..fac6243b9
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/implode.kt
@@ -0,0 +1,27 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import org.jetbrains.kotlinx.dataframe.ColumnsSelector
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.DataRow
+import org.jetbrains.kotlinx.dataframe.columns.ColumnReference
+import org.jetbrains.kotlinx.dataframe.columns.toColumnSet
+import org.jetbrains.kotlinx.dataframe.impl.api.implodeImpl
+import kotlin.reflect.KProperty
+
+// region DataFrame
+
+public fun <T> DataFrame<T>.implode(dropNA: Boolean = false): DataRow<T> = implode(dropNA) { all() }[0]
+
+public fun <T, C> DataFrame<T>.implode(dropNA: Boolean = false, columns: ColumnsSelector<T, C>): DataFrame<T> =
+    implodeImpl(dropNA, columns)
+
+public fun <T> DataFrame<T>.implode(vararg columns: String, dropNA: Boolean = false): DataFrame<T> =
+    implode(dropNA) { columns.toColumnSet() }
+
+public fun <T, C> DataFrame<T>.implode(vararg columns: ColumnReference<C>, dropNA: Boolean = false): DataFrame<T> =
+    implode(dropNA) { columns.toColumnSet() }
+
+public fun <T, C> DataFrame<T>.implode(vararg columns: KProperty<C>, dropNA: Boolean = false): DataFrame<T> =
+    implode(dropNA) { columns.toColumnSet() }
+
+// endregion
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/indices.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/indices.kt
new file mode 100644
index 000000000..6edc8c300
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/indices.kt
@@ -0,0 +1,18 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import org.jetbrains.kotlinx.dataframe.AnyFrame
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.RowFilter
+import org.jetbrains.kotlinx.dataframe.indices
+
+// region DataFrame
+
+public fun AnyFrame.indices(): IntRange = 0 until rowsCount()
+
+public fun <T> DataFrame<T>.indices(filter: RowFilter<T>): List<Int> =
+    indices.filter {
+        val row = get(it)
+        filter(row, row)
+    }
+
+// endregion
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/inferType.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/inferType.kt
new file mode 100644
index 000000000..eab0222ee
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/inferType.kt
@@ -0,0 +1,29 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import org.jetbrains.kotlinx.dataframe.AnyCol
+import org.jetbrains.kotlinx.dataframe.ColumnsSelector
+import org.jetbrains.kotlinx.dataframe.DataColumn
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.columns.ColumnReference
+import org.jetbrains.kotlinx.dataframe.columns.toColumnSet
+import org.jetbrains.kotlinx.dataframe.impl.columns.guessColumnType
+import org.jetbrains.kotlinx.dataframe.type
+import kotlin.reflect.KProperty
+
+public fun AnyCol.inferType(): DataColumn<*> = guessColumnType(name, toList(), type, true)
+
+// region DataFrame
+
+public fun <T> DataFrame<T>.inferType(): DataFrame<T> = inferType { colsAtAnyDepth { !it.isColumnGroup() } }
+
+public fun <T> DataFrame<T>.inferType(columns: ColumnsSelector<T, *>): DataFrame<T> =
+    replace(columns).with { it.inferType() }
+
+public fun <T> DataFrame<T>.inferType(vararg columns: String): DataFrame<T> = inferType { columns.toColumnSet() }
+
+public fun <T> DataFrame<T>.inferType(vararg columns: ColumnReference<*>): DataFrame<T> =
+    inferType { columns.toColumnSet() }
+
+public fun <T> DataFrame<T>.inferType(vararg columns: KProperty<*>): DataFrame<T> = inferType { columns.toColumnSet() }
+
+// endregion
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/into.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/into.kt
new file mode 100644
index 000000000..7026b72e4
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/into.kt
@@ -0,0 +1,82 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import org.jetbrains.kotlinx.dataframe.AnyFrame
+import org.jetbrains.kotlinx.dataframe.AnyRow
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.RowExpression
+import org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor
+import org.jetbrains.kotlinx.dataframe.impl.aggregation.internal
+import org.jetbrains.kotlinx.dataframe.impl.aggregation.withExpr
+import org.jetbrains.kotlinx.dataframe.impl.columnName
+import kotlin.reflect.KProperty
+import kotlin.reflect.typeOf
+
+// region GroupBy
+
+public fun <T, G> GroupBy<T, G>.into(column: String): DataFrame<T> = toDataFrame(column)
+
+public fun <T> GroupBy<T, *>.into(column: ColumnAccessor<AnyFrame>): DataFrame<T> = toDataFrame(column.name())
+
+public fun <T> GroupBy<T, *>.into(column: KProperty<AnyFrame>): DataFrame<T> = toDataFrame(column.columnName)
+
+public inline fun <T, G, reified V> GroupBy<T, G>.into(
+    columnName: String? = null,
+    noinline expression: RowExpression<G, V>,
+): DataFrame<G> = into(pathOf(columnName ?: groups.name()).cast(), expression)
+
+public inline fun <T, G, reified V> GroupBy<T, G>.into(
+    column: ColumnAccessor<V>,
+    noinline expression: RowExpression<G, V>,
+): DataFrame<G> {
+    val type = typeOf<V>()
+    val path = column.path()
+    return aggregate {
+        internal().withExpr(type, path, expression)
+    }
+}
+
+public inline fun <T, G, reified V> GroupBy<T, G>.into(
+    column: KProperty<V>,
+    noinline expression: RowExpression<G, V>,
+): DataFrame<G> = into(column.columnName, expression)
+
+// endregion
+
+// region ReducedGroupBy
+
+public inline fun <T, G, reified V> ReducedGroupBy<T, G>.into(
+    columnName: String? = null,
+    noinline expression: RowExpression<G, V>,
+): DataFrame<G> {
+    val type = typeOf<V>()
+    val name = columnName ?: groupBy.groups.name()
+    return groupBy.aggregate {
+        val row = reducer(it, it)
+        if (row != null) {
+            internal().yield(pathOf(name), expression(row, row), type)
+        }
+    }
+}
+
+public inline fun <T, G, reified V> ReducedGroupBy<T, G>.into(
+    column: ColumnAccessor<V>,
+    noinline expression: RowExpression<G, V>,
+): DataFrame<G> = into(column.name(), expression)
+
+public inline fun <T, G, reified V> ReducedGroupBy<T, G>.into(
+    column: KProperty<V>,
+    noinline expression: RowExpression<G, V>,
+): DataFrame<G> = into(column.columnName, expression)
+
+public fun <T, G> ReducedGroupBy<T, G>.into(columnName: String): DataFrame<G> = into(columnName) { this }
+
+public fun <T, G> ReducedGroupBy<T, G>.into(column: ColumnAccessor<AnyRow>): DataFrame<G> = into(column) { this }
+
+public fun <T, G> ReducedGroupBy<T, G>.into(column: KProperty<AnyRow>): DataFrame<G> = into(column) { this }
+
+public fun <T, G> ReducedGroupBy<T, G>.concat(): DataFrame<G> =
+    groupBy.groups.values()
+        .map { reducer(it, it) }
+        .concat()
+
+// endregion
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/isEmpty.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/isEmpty.kt
new file mode 100644
index 000000000..cc38be3bd
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/isEmpty.kt
@@ -0,0 +1,13 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import org.jetbrains.kotlinx.dataframe.AnyFrame
+import org.jetbrains.kotlinx.dataframe.ncol
+import org.jetbrains.kotlinx.dataframe.nrow
+
+// region DataFrame
+
+public fun AnyFrame.isEmpty(): Boolean = ncol == 0 || nrow == 0
+
+public fun AnyFrame.isNotEmpty(): Boolean = !isEmpty()
+
+// endregion
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/join.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/join.kt
new file mode 100644
index 000000000..ea54b2c3b
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/join.kt
@@ -0,0 +1,137 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import org.jetbrains.kotlinx.dataframe.ColumnsContainer
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.annotations.Interpretable
+import org.jetbrains.kotlinx.dataframe.annotations.Refine
+import org.jetbrains.kotlinx.dataframe.columns.ColumnReference
+import org.jetbrains.kotlinx.dataframe.columns.ColumnResolutionContext
+import org.jetbrains.kotlinx.dataframe.columns.ColumnSet
+import org.jetbrains.kotlinx.dataframe.columns.ColumnWithPath
+import org.jetbrains.kotlinx.dataframe.columns.ColumnsResolver
+import org.jetbrains.kotlinx.dataframe.columns.toColumnSet
+import org.jetbrains.kotlinx.dataframe.impl.api.joinImpl
+import kotlin.reflect.KProperty
+
+@Refine
+@Interpretable("Join0")
+public fun <A, B> DataFrame<A>.join(
+    other: DataFrame<B>,
+    type: JoinType = JoinType.Inner,
+    selector: JoinColumnsSelector<A, B>? = null,
+): DataFrame<A> = joinImpl(other, type, addNewColumns = type.addNewColumns, selector)
+
+public fun <A, B> DataFrame<A>.join(
+    other: DataFrame<B>,
+    vararg columns: String,
+    type: JoinType = JoinType.Inner,
+): DataFrame<A> = join(other, type) { columns.toColumnSet() }
+
+public fun <A, B> DataFrame<A>.innerJoin(
+    other: DataFrame<B>,
+    selector: JoinColumnsSelector<A, B>? = null,
+): DataFrame<A> = join(other, JoinType.Inner, selector = selector)
+
+public fun <A, B> DataFrame<A>.innerJoin(other: DataFrame<B>, vararg columns: String): DataFrame<A> =
+    innerJoin(other) { columns.toColumnSet() }
+
+public fun <A, B> DataFrame<A>.leftJoin(
+    other: DataFrame<B>,
+    selector: JoinColumnsSelector<A, B>? = null,
+): DataFrame<A> = join(other, JoinType.Left, selector = selector)
+
+public fun <A, B> DataFrame<A>.leftJoin(other: DataFrame<B>, vararg columns: String): DataFrame<A> =
+    leftJoin(other) { columns.toColumnSet() }
+
+public fun <A, B> DataFrame<A>.rightJoin(
+    other: DataFrame<B>,
+    selector: JoinColumnsSelector<A, B>? = null,
+): DataFrame<A> = join(other, JoinType.Right, selector = selector)
+
+public fun <A, B> DataFrame<A>.rightJoin(other: DataFrame<B>, vararg columns: String): DataFrame<A> =
+    rightJoin(other) { columns.toColumnSet() }
+
+public fun <A, B> DataFrame<A>.fullJoin(
+    other: DataFrame<B>,
+    selector: JoinColumnsSelector<A, B>? = null,
+): DataFrame<A> = join(other, JoinType.Full, selector = selector)
+
+public fun <A, B> DataFrame<A>.fullJoin(other: DataFrame<B>, vararg columns: String): DataFrame<A> =
+    fullJoin(other) { columns.toColumnSet() }
+
+public fun <A, B> DataFrame<A>.filterJoin(
+    other: DataFrame<B>,
+    selector: JoinColumnsSelector<A, B>? = null,
+): DataFrame<A> = joinImpl(other, JoinType.Inner, addNewColumns = false, selector = selector)
+
+public fun <A, B> DataFrame<A>.filterJoin(other: DataFrame<B>, vararg columns: String): DataFrame<A> =
+    filterJoin(other) { columns.toColumnSet() }
+
+public fun <A, B> DataFrame<A>.excludeJoin(
+    other: DataFrame<B>,
+    selector: JoinColumnsSelector<A, B>? = null,
+): DataFrame<A> = joinImpl(other, JoinType.Exclude, addNewColumns = false, selector = selector)
+
+public fun <A, B> DataFrame<A>.excludeJoin(other: DataFrame<B>, vararg columns: String): DataFrame<A> =
+    excludeJoin(other) { columns.toColumnSet() }
+
+public fun <T> Iterable<DataFrame<T>>.joinOrNull(
+    joinType: JoinType = JoinType.Inner,
+    selector: JoinColumnsSelector<T, T>? = null,
+): DataFrame<T>? =
+    fold<DataFrame<T>, DataFrame<T>?>(null) { joined, new -> joined?.join(new, joinType, selector = selector) ?: new }
+
+public interface JoinDsl<out A, out B> : ColumnsSelectionDsl<A> {
+
+    public val right: DataFrame<B>
+
+    @Interpretable("Match0")
+    public infix fun <C> ColumnReference<C>.match(other: ColumnReference<C>): ColumnMatch<C> = ColumnMatch(this, other)
+
+    public infix fun <C> String.match(other: ColumnReference<C>): ColumnMatch<C> = ColumnMatch(toColumnOf(), other)
+
+    public infix fun <C> ColumnReference<C>.match(other: String): ColumnMatch<C> = ColumnMatch(this, other.toColumnOf())
+
+    public infix fun String.match(other: String): ColumnMatch<Any?> =
+        ColumnMatch(toColumnAccessor(), other.toColumnAccessor())
+
+    public infix fun <C> KProperty<C>.match(other: KProperty<C>): ColumnMatch<C> =
+        ColumnMatch(toColumnAccessor(), other.toColumnAccessor())
+
+    public infix fun <C> ColumnReference<C>.match(other: KProperty<C>): ColumnMatch<C> =
+        ColumnMatch(this, other.toColumnAccessor())
+
+    public infix fun <C> KProperty<C>.match(other: ColumnReference<C>): ColumnMatch<C> =
+        ColumnMatch(toColumnAccessor(), other)
+}
+
+public class ColumnMatch<C>(public val left: ColumnReference<C>, public val right: ColumnReference<C>) : ColumnSet<C> {
+
+    override fun resolve(context: ColumnResolutionContext): List<ColumnWithPath<C>> =
+        throw UnsupportedOperationException()
+}
+
+public typealias JoinColumnsSelector<A, B> = JoinDsl<A, B>.(ColumnsContainer<A>) -> ColumnsResolver<*>
+
+public enum class JoinType {
+    Left, // all data from left data frame, nulls for mismatches in right data frame
+    Right, // all data from right data frame, nulls for mismatches in left data frame
+    Inner, // only matched data from right and left data frame
+    Filter, // only matched data from left data frame
+    Full, // all data from left and from right data frame, nulls for any mismatches
+    Exclude, // mismatched rows from left data frame
+}
+
+internal val JoinType.addNewColumns: Boolean
+    get() = when (this) {
+        JoinType.Filter, JoinType.Exclude -> false
+        JoinType.Left, JoinType.Right, JoinType.Inner, JoinType.Full -> true
+    }
+
+public val JoinType.allowLeftNulls: Boolean
+    get() = this == JoinType.Right || this == JoinType.Full
+
+public val JoinType.allowRightNulls: Boolean
+    get() = this == JoinType.Left ||
+        this == JoinType.Full ||
+        this == JoinType.Exclude
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/joinWith.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/joinWith.kt
new file mode 100644
index 000000000..a6453dba2
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/joinWith.kt
@@ -0,0 +1,38 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.DataRow
+import org.jetbrains.kotlinx.dataframe.Selector
+import org.jetbrains.kotlinx.dataframe.impl.api.joinWithImpl
+
+public interface JoinedDataRow<out A, out B> : DataRow<A> {
+    public val right: DataRow<B>
+}
+
+public typealias JoinExpression<A, B> = Selector<JoinedDataRow<A, B>, Boolean>
+
+public fun <A, B> DataFrame<A>.joinWith(
+    right: DataFrame<B>,
+    type: JoinType = JoinType.Inner,
+    joinExpression: JoinExpression<A, B>,
+): DataFrame<A> = joinWithImpl(right, type, addNewColumns = type.addNewColumns, joinExpression)
+
+public fun <A, B> DataFrame<A>.innerJoinWith(right: DataFrame<B>, joinExpression: JoinExpression<A, B>): DataFrame<A> =
+    joinWith(right, JoinType.Inner, joinExpression)
+
+public fun <A, B> DataFrame<A>.leftJoinWith(right: DataFrame<B>, joinExpression: JoinExpression<A, B>): DataFrame<A> =
+    joinWith(right, JoinType.Left, joinExpression)
+
+public fun <A, B> DataFrame<A>.rightJoinWith(right: DataFrame<B>, joinExpression: JoinExpression<A, B>): DataFrame<A> =
+    joinWith(right, JoinType.Right, joinExpression)
+
+public fun <A, B> DataFrame<A>.fullJoinWith(right: DataFrame<B>, joinExpression: JoinExpression<A, B>): DataFrame<A> =
+    joinWith(right, JoinType.Full, joinExpression)
+
+public fun <A, B> DataFrame<A>.filterJoinWith(right: DataFrame<B>, joinExpression: JoinExpression<A, B>): DataFrame<A> =
+    joinWithImpl(right, JoinType.Inner, addNewColumns = false, joinExpression)
+
+public fun <A, B> DataFrame<A>.excludeJoinWith(
+    right: DataFrame<B>,
+    joinExpression: JoinExpression<A, B>,
+): DataFrame<A> = joinWithImpl(right, JoinType.Exclude, addNewColumns = false, joinExpression)
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/last.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/last.kt
new file mode 100644
index 000000000..9c95dbda8
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/last.kt
@@ -0,0 +1,384 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import org.jetbrains.kotlinx.dataframe.ColumnFilter
+import org.jetbrains.kotlinx.dataframe.DataColumn
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.DataRow
+import org.jetbrains.kotlinx.dataframe.RowFilter
+import org.jetbrains.kotlinx.dataframe.api.LastColumnsSelectionDsl.Grammar
+import org.jetbrains.kotlinx.dataframe.columns.ColumnGroup
+import org.jetbrains.kotlinx.dataframe.columns.ColumnPath
+import org.jetbrains.kotlinx.dataframe.columns.ColumnReference
+import org.jetbrains.kotlinx.dataframe.columns.ColumnSet
+import org.jetbrains.kotlinx.dataframe.columns.SingleColumn
+import org.jetbrains.kotlinx.dataframe.columns.asColumnSet
+import org.jetbrains.kotlinx.dataframe.columns.size
+import org.jetbrains.kotlinx.dataframe.columns.values
+import org.jetbrains.kotlinx.dataframe.impl.columns.TransformableColumnSet
+import org.jetbrains.kotlinx.dataframe.impl.columns.TransformableSingleColumn
+import org.jetbrains.kotlinx.dataframe.impl.columns.singleOrNullWithTransformerImpl
+import org.jetbrains.kotlinx.dataframe.impl.columns.transform
+import org.jetbrains.kotlinx.dataframe.nrow
+import kotlin.reflect.KProperty
+
+// region DataColumn
+
+public fun <T> DataColumn<T>.last(): T = get(size - 1)
+
+public fun <T> DataColumn<T>.lastOrNull(): T? = if (size > 0) last() else null
+
+public fun <T> DataColumn<T>.last(predicate: (T) -> Boolean): T = values.last(predicate)
+
+public fun <T> DataColumn<T>.lastOrNull(predicate: (T) -> Boolean): T? = values.lastOrNull(predicate)
+
+// endregion
+
+// region DataFrame
+
+public fun <T> DataFrame<T>.lastOrNull(predicate: RowFilter<T>): DataRow<T>? =
+    rowsReversed().firstOrNull { predicate(it, it) }
+
+public fun <T> DataFrame<T>.last(predicate: RowFilter<T>): DataRow<T> = rowsReversed().first { predicate(it, it) }
+
+public fun <T> DataFrame<T>.lastOrNull(): DataRow<T>? = if (nrow > 0) get(nrow - 1) else null
+
+public fun <T> DataFrame<T>.last(): DataRow<T> {
+    if (nrow == 0) {
+        throw NoSuchElementException("DataFrame has no rows. Use `lastOrNull`.")
+    }
+    return get(nrow - 1)
+}
+
+// endregion
+
+// region GroupBy
+
+public fun <T, G> GroupBy<T, G>.last(): ReducedGroupBy<T, G> = reduce { lastOrNull() }
+
+public fun <T, G> GroupBy<T, G>.last(predicate: RowFilter<G>): ReducedGroupBy<T, G> = reduce { lastOrNull(predicate) }
+
+// endregion
+
+// region Pivot
+
+public fun <T> Pivot<T>.last(): ReducedPivot<T> = reduce { lastOrNull() }
+
+public fun <T> Pivot<T>.last(predicate: RowFilter<T>): ReducedPivot<T> = reduce { lastOrNull(predicate) }
+
+// endregion
+
+// region PivotGroupBy
+
+public fun <T> PivotGroupBy<T>.last(): ReducedPivotGroupBy<T> = reduce { lastOrNull() }
+
+public fun <T> PivotGroupBy<T>.last(predicate: RowFilter<T>): ReducedPivotGroupBy<T> = reduce { lastOrNull(predicate) }
+
+// endregion
+
+// region ColumnsSelectionDsl
+
+/**
+ * # Last (Col) [Columns Selection DSL][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl]
+ *
+ * See [Grammar] for all functions in this interface.
+ */
+public interface LastColumnsSelectionDsl {
+
+    /**
+     * ## Last (Col) Grammar
+     *
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * [(What is this notation?)][org.jetbrains.kotlinx.dataframe.documentation.DslGrammar]
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  ### Definitions:
+     *  `columnSet: `[`ColumnSet`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]`<*>`
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  `columnGroup: `[`SingleColumn`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]`<`[`DataRow`][org.jetbrains.kotlinx.dataframe.DataRow]`<*>> | `[`String`][String]`  |  `[`KProperty`][kotlin.reflect.KProperty]`<* | `[`DataRow`][org.jetbrains.kotlinx.dataframe.DataRow]`<*>> | `[`ColumnPath`][org.jetbrains.kotlinx.dataframe.columns.ColumnPath]
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  `condition: `[`ColumnFilter`][org.jetbrains.kotlinx.dataframe.ColumnFilter]
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  ### What can be called directly in the [Columns Selection DSL][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl]:
+     *
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  [**`last`**][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.last]`  [  `**`{ `**[`condition`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ConditionDef]**` }`**` ]`
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  ### What can be called on a [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]:
+     *
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  [`columnSet`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ColumnSetDef]
+     *
+     *  &nbsp;&nbsp;&nbsp;&nbsp;__`.`__[**`last`**][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.last]`  [  `**`{ `**[`condition`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ConditionDef]**` }`**` ]`
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  ### What can be called on a [Column Group (reference)][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ColumnGroupDef]:
+     *
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  [`columnGroup`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ColumnGroupDef]
+     *
+     *  &nbsp;&nbsp;&nbsp;&nbsp;__`.`__[**`lastCol`**][org.jetbrains.kotlinx.dataframe.api.LastColumnsSelectionDsl.lastCol]`  [  `**`{ `**[`condition`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ConditionDef]**` }`**` ]`
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     */
+    public interface Grammar {
+
+        /** [**`last`**][ColumnsSelectionDsl.last] */
+        public interface PlainDslName
+
+        /** __`.`__[**`last`**][ColumnsSelectionDsl.last] */
+        public interface ColumnSetName
+
+        /** __`.`__[**`lastCol`**][ColumnsSelectionDsl.lastCol] */
+        public interface ColumnGroupName
+    }
+
+    /**
+     * ## Last (Col)
+     * Returns the last column from [this] that adheres to the optional given [condition].
+     * If no column adheres to the given [condition], [NoSuchElementException] is thrown.
+     *
+     * This function operates solely on columns at the top-level.
+     *
+     * NOTE: For [column groups][ColumnGroup], `last` is named `lastCol` instead to avoid confusion.
+     *
+     * ### Check out: [Grammar]
+     *
+     * #### Examples:
+     *
+     * `df.`[select][DataFrame.select]`  {  `[last][ColumnsSelectionDsl.last]` { it.`[name][ColumnReference.name]`().`[startsWith][String.startsWith]`("order") } }`
+     *
+     * `df.`[select][DataFrame.select]` { "myColumnGroup".`[lastCol][String.lastCol]` { it.`[name][ColumnReference.name]`().`[startsWith][String.startsWith]`("order") } }`
+     *
+     * #### Examples for this overload:
+     *
+     *
+     *
+     * @param [condition] The optional [ColumnFilter] condition that the column must adhere to.
+     * @return A [SingleColumn] containing the last column
+     *   that adheres to the given [condition].
+     * @throws [NoSuchElementException] if no column adheres to the given [condition].
+     * @see [ColumnsSelectionDsl.first]
+     */
+    private interface CommonLastDocs {
+
+        /** Examples key */
+        interface Examples
+    }
+
+    /**
+     * ## Last (Col)
+     * Returns the last column from [this] that adheres to the optional given [condition].
+     * If no column adheres to the given [condition], [NoSuchElementException] is thrown.
+     *
+     * This function operates solely on columns at the top-level.
+     *
+     * NOTE: For [column groups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup], `last` is named `lastCol` instead to avoid confusion.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.LastColumnsSelectionDsl.Grammar]
+     *
+     * #### Examples:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[last][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.last]` { it.`[name][org.jetbrains.kotlinx.dataframe.columns.ColumnReference.name]`().`[startsWith][String.startsWith]`("order") } }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "myColumnGroup".`[lastCol][kotlin.String.lastCol]` { it.`[name][org.jetbrains.kotlinx.dataframe.columns.ColumnReference.name]`().`[startsWith][String.startsWith]`("order") } }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][DataFrame.select]`  {  `[colsOf][SingleColumn.colsOf]`<`[String][String]`>().`[last][ColumnSet.last]` { it.`[name][ColumnReference.name]`().`[startsWith][String.startsWith]`("year") } }`
+     *
+     * `df.`[select][DataFrame.select]`  {  `[colsOf][SingleColumn.colsOf]`<`[Int][Int]`>().`[last][ColumnSet.last]`() }`
+     *
+     * @param [condition] The optional [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter] condition that the column must adhere to.
+     * @return A [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn] containing the last column
+     *   that adheres to the given [condition].
+     * @throws [NoSuchElementException] if no column adheres to the given [condition].
+     * @see [ColumnsSelectionDsl.first]
+     */
+    @Suppress("UNCHECKED_CAST")
+    public fun <C> ColumnSet<C>.last(condition: ColumnFilter<C> = { true }): TransformableSingleColumn<C> =
+        (allColumnsInternal() as TransformableColumnSet<C>)
+            .transform { listOf(it.last(condition)) }
+            .singleOrNullWithTransformerImpl()
+
+    /**
+     * ## Last (Col)
+     * Returns the last column from [this] that adheres to the optional given [condition].
+     * If no column adheres to the given [condition], [NoSuchElementException] is thrown.
+     *
+     * This function operates solely on columns at the top-level.
+     *
+     * NOTE: For [column groups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup], `last` is named `lastCol` instead to avoid confusion.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.LastColumnsSelectionDsl.Grammar]
+     *
+     * #### Examples:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[last][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.last]` { it.`[name][org.jetbrains.kotlinx.dataframe.columns.ColumnReference.name]`().`[startsWith][String.startsWith]`("order") } }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "myColumnGroup".`[lastCol][kotlin.String.lastCol]` { it.`[name][org.jetbrains.kotlinx.dataframe.columns.ColumnReference.name]`().`[startsWith][String.startsWith]`("order") } }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][DataFrame.select]`  {  `[last][ColumnsSelectionDsl.last]` { it.`[name][ColumnReference.name]`().`[startsWith][String.startsWith]`("year") } }`
+     *
+     * @param [condition] The optional [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter] condition that the column must adhere to.
+     * @return A [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn] containing the last column
+     *   that adheres to the given [condition].
+     * @throws [NoSuchElementException] if no column adheres to the given [condition].
+     * @see [ColumnsSelectionDsl.first]
+     */
+    public fun ColumnsSelectionDsl<*>.last(condition: ColumnFilter<*> = { true }): TransformableSingleColumn<*> =
+        asSingleColumn().lastCol(condition)
+
+    /**
+     * ## Last (Col)
+     * Returns the last column from [this] that adheres to the optional given [condition].
+     * If no column adheres to the given [condition], [NoSuchElementException] is thrown.
+     *
+     * This function operates solely on columns at the top-level.
+     *
+     * NOTE: For [column groups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup], `last` is named `lastCol` instead to avoid confusion.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.LastColumnsSelectionDsl.Grammar]
+     *
+     * #### Examples:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[last][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.last]` { it.`[name][org.jetbrains.kotlinx.dataframe.columns.ColumnReference.name]`().`[startsWith][String.startsWith]`("order") } }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "myColumnGroup".`[lastCol][kotlin.String.lastCol]` { it.`[name][org.jetbrains.kotlinx.dataframe.columns.ColumnReference.name]`().`[startsWith][String.startsWith]`("order") } }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][DataFrame.select]` { myColumnGroup.`[lastCol][SingleColumn.lastCol]`() }`
+     *
+     * @param [condition] The optional [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter] condition that the column must adhere to.
+     * @return A [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn] containing the last column
+     *   that adheres to the given [condition].
+     * @throws [NoSuchElementException] if no column adheres to the given [condition].
+     * @see [ColumnsSelectionDsl.first]
+     */
+    public fun SingleColumn<DataRow<*>>.lastCol(condition: ColumnFilter<*> = { true }): TransformableSingleColumn<*> =
+        this.ensureIsColumnGroup().asColumnSet().last(condition)
+
+    /**
+     * ## Last (Col)
+     * Returns the last column from [this] that adheres to the optional given [condition].
+     * If no column adheres to the given [condition], [NoSuchElementException] is thrown.
+     *
+     * This function operates solely on columns at the top-level.
+     *
+     * NOTE: For [column groups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup], `last` is named `lastCol` instead to avoid confusion.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.LastColumnsSelectionDsl.Grammar]
+     *
+     * #### Examples:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[last][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.last]` { it.`[name][org.jetbrains.kotlinx.dataframe.columns.ColumnReference.name]`().`[startsWith][String.startsWith]`("order") } }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "myColumnGroup".`[lastCol][kotlin.String.lastCol]` { it.`[name][org.jetbrains.kotlinx.dataframe.columns.ColumnReference.name]`().`[startsWith][String.startsWith]`("order") } }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][DataFrame.select]` { "myColumnGroup".`[lastCol][String.lastCol]` { it.`[name][ColumnReference.name]`().`[startsWith][String.startsWith]`("year") } }`
+     *
+     * @param [condition] The optional [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter] condition that the column must adhere to.
+     * @return A [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn] containing the last column
+     *   that adheres to the given [condition].
+     * @throws [NoSuchElementException] if no column adheres to the given [condition].
+     * @see [ColumnsSelectionDsl.first]
+     */
+    public fun String.lastCol(condition: ColumnFilter<*> = { true }): TransformableSingleColumn<*> =
+        columnGroup(this).lastCol(condition)
+
+    /**
+     * ## Last (Col)
+     * Returns the last column from [this] that adheres to the optional given [condition].
+     * If no column adheres to the given [condition], [NoSuchElementException] is thrown.
+     *
+     * This function operates solely on columns at the top-level.
+     *
+     * NOTE: For [column groups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup], `last` is named `lastCol` instead to avoid confusion.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.LastColumnsSelectionDsl.Grammar]
+     *
+     * #### Examples:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[last][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.last]` { it.`[name][org.jetbrains.kotlinx.dataframe.columns.ColumnReference.name]`().`[startsWith][String.startsWith]`("order") } }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "myColumnGroup".`[lastCol][kotlin.String.lastCol]` { it.`[name][org.jetbrains.kotlinx.dataframe.columns.ColumnReference.name]`().`[startsWith][String.startsWith]`("order") } }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][DataFrame.select]` { Type::myColumnGroup.`[lastCol][SingleColumn.lastCol]` { it.`[name][ColumnReference.name]`().`[startsWith][String.startsWith]`("year") } }`
+     *
+     * `df.`[select][DataFrame.select]` { DataSchemaType::myColumnGroup.`[lastCol][KProperty.lastCol]`() }`
+     *
+     * @param [condition] The optional [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter] condition that the column must adhere to.
+     * @return A [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn] containing the last column
+     *   that adheres to the given [condition].
+     * @throws [NoSuchElementException] if no column adheres to the given [condition].
+     * @see [ColumnsSelectionDsl.first]
+     */
+    public fun KProperty<*>.lastCol(condition: ColumnFilter<*> = { true }): TransformableSingleColumn<*> =
+        columnGroup(this).lastCol(condition)
+
+    /**
+     * ## Last (Col)
+     * Returns the last column from [this] that adheres to the optional given [condition].
+     * If no column adheres to the given [condition], [NoSuchElementException] is thrown.
+     *
+     * This function operates solely on columns at the top-level.
+     *
+     * NOTE: For [column groups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup], `last` is named `lastCol` instead to avoid confusion.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.LastColumnsSelectionDsl.Grammar]
+     *
+     * #### Examples:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[last][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.last]` { it.`[name][org.jetbrains.kotlinx.dataframe.columns.ColumnReference.name]`().`[startsWith][String.startsWith]`("order") } }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "myColumnGroup".`[lastCol][kotlin.String.lastCol]` { it.`[name][org.jetbrains.kotlinx.dataframe.columns.ColumnReference.name]`().`[startsWith][String.startsWith]`("order") } }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][DataFrame.select]` { "pathTo"["myColumnGroup"].`[lastCol][ColumnPath.lastCol]` { it.`[name][ColumnReference.name]`().`[startsWith][String.startsWith]`("year") } }`
+     *
+     * @param [condition] The optional [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter] condition that the column must adhere to.
+     * @return A [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn] containing the last column
+     *   that adheres to the given [condition].
+     * @throws [NoSuchElementException] if no column adheres to the given [condition].
+     * @see [ColumnsSelectionDsl.first]
+     */
+    public fun ColumnPath.lastCol(condition: ColumnFilter<*> = { true }): TransformableSingleColumn<*> =
+        columnGroup(this).lastCol(condition)
+}
+
+// endregion
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/length.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/length.kt
new file mode 100644
index 000000000..3c9eb65af
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/length.kt
@@ -0,0 +1,10 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import org.jetbrains.kotlinx.dataframe.DataColumn
+import org.jetbrains.kotlinx.dataframe.StringCol
+
+// region StringCol
+
+public fun StringCol.length(): DataColumn<Int> = map { it?.length ?: 0 }
+
+// endregion
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/lowercase.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/lowercase.kt
new file mode 100644
index 000000000..1f10f5991
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/lowercase.kt
@@ -0,0 +1,9 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import org.jetbrains.kotlinx.dataframe.StringCol
+
+// region StringCol
+
+public fun StringCol.lowercase(): StringCol = map { it?.lowercase() }
+
+// endregion
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/map.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/map.kt
new file mode 100644
index 000000000..6907c9e0b
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/map.kt
@@ -0,0 +1,132 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import org.jetbrains.kotlinx.dataframe.AnyFrame
+import org.jetbrains.kotlinx.dataframe.ColumnsContainer
+import org.jetbrains.kotlinx.dataframe.DataColumn
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.DataRow
+import org.jetbrains.kotlinx.dataframe.RowExpression
+import org.jetbrains.kotlinx.dataframe.Selector
+import org.jetbrains.kotlinx.dataframe.annotations.Interpretable
+import org.jetbrains.kotlinx.dataframe.annotations.Refine
+import org.jetbrains.kotlinx.dataframe.columns.ColumnReference
+import org.jetbrains.kotlinx.dataframe.columns.FrameColumn
+import org.jetbrains.kotlinx.dataframe.impl.columnName
+import org.jetbrains.kotlinx.dataframe.impl.columns.createComputedColumnReference
+import org.jetbrains.kotlinx.dataframe.impl.columns.newColumn
+import kotlin.reflect.KProperty
+import kotlin.reflect.KType
+import kotlin.reflect.typeOf
+
+// region ColumnReference
+
+public inline fun <C, reified R> ColumnReference<C>.map(
+    infer: Infer = Infer.Nulls,
+    noinline transform: (C) -> R,
+): ColumnReference<R> = createComputedColumnReference(name(), typeOf<R>(), infer) { transform(this@map()) }
+
+// endregion
+
+// region DataColumn
+
+public inline fun <T, reified R> DataColumn<T>.map(
+    infer: Infer = Infer.Nulls,
+    crossinline transform: (T) -> R,
+): DataColumn<R> {
+    val newValues = Array(size()) { transform(get(it)) }.asList()
+    return DataColumn.create(name(), newValues, typeOf<R>(), infer)
+}
+
+public fun <T, R> DataColumn<T>.map(type: KType, infer: Infer = Infer.Nulls, transform: (T) -> R): DataColumn<R> {
+    val values = Array<Any?>(size()) { transform(get(it)) }.asList()
+    return DataColumn.create(name(), values, type, infer).cast()
+}
+
+public inline fun <T, reified R> DataColumn<T>.mapIndexed(
+    infer: Infer = Infer.Nulls,
+    crossinline transform: (Int, T) -> R,
+): DataColumn<R> {
+    val newValues = Array(size()) { transform(it, get(it)) }.asList()
+    return DataColumn.create(name(), newValues, typeOf<R>(), infer)
+}
+
+public fun <T, R> DataColumn<T>.mapIndexed(
+    type: KType,
+    infer: Infer = Infer.Nulls,
+    transform: (Int, T) -> R,
+): DataColumn<R> {
+    val values = Array<Any?>(size()) { transform(it, get(it)) }.asList()
+    return DataColumn.create(name(), values, type, infer).cast()
+}
+
+// endregion
+
+// region DataFrame
+
+public fun <T, R> DataFrame<T>.map(transform: RowExpression<T, R>): List<R> = rows().map { transform(it, it) }
+
+public inline fun <T, reified R> ColumnsContainer<T>.mapToColumn(
+    name: String,
+    infer: Infer = Infer.Nulls,
+    noinline body: AddExpression<T, R>,
+): DataColumn<R> = mapToColumn(name, typeOf<R>(), infer, body)
+
+public inline fun <T, reified R> ColumnsContainer<T>.mapToColumn(
+    column: ColumnReference<R>,
+    infer: Infer = Infer.Nulls,
+    noinline body: AddExpression<T, R>,
+): DataColumn<R> = mapToColumn(column, typeOf<R>(), infer, body)
+
+public inline fun <T, reified R> ColumnsContainer<T>.mapToColumn(
+    column: KProperty<R>,
+    infer: Infer = Infer.Nulls,
+    noinline body: AddExpression<T, R>,
+): DataColumn<R> = mapToColumn(column, typeOf<R>(), infer, body)
+
+public fun <T, R> ColumnsContainer<T>.mapToColumn(
+    name: String,
+    type: KType,
+    infer: Infer = Infer.Nulls,
+    body: AddExpression<T, R>,
+): DataColumn<R> = newColumn(type, name, infer, body)
+
+public fun <T, R> ColumnsContainer<T>.mapToColumn(
+    column: ColumnReference<R>,
+    type: KType,
+    infer: Infer = Infer.Nulls,
+    body: AddExpression<T, R>,
+): DataColumn<R> = mapToColumn(column.name(), type, infer, body)
+
+public fun <T, R> ColumnsContainer<T>.mapToColumn(
+    column: KProperty<R>,
+    type: KType,
+    infer: Infer = Infer.Nulls,
+    body: AddExpression<T, R>,
+): DataColumn<R> = mapToColumn(column.columnName, type, infer, body)
+
+@Refine
+@Interpretable("MapToFrame")
+public fun <T> DataFrame<T>.mapToFrame(body: AddDsl<T>.() -> Unit): AnyFrame {
+    val dsl = AddDsl(this)
+    body(dsl)
+    return dataFrameOf(dsl.columns)
+}
+
+// endregion
+
+// region GroupBy
+
+public fun <T, G, R> GroupBy<T, G>.map(body: Selector<GroupWithKey<T, G>, R>): List<R> =
+    keys.rows().mapIndexedNotNull { index, row ->
+        val group = groups[index]
+        val g = GroupWithKey(row, group)
+        body(g, g)
+    }
+
+public fun <T, G> GroupBy<T, G>.mapToRows(body: Selector<GroupWithKey<T, G>, DataRow<G>?>): DataFrame<G> =
+    map(body).concat()
+
+public fun <T, G> GroupBy<T, G>.mapToFrames(body: Selector<GroupWithKey<T, G>, DataFrame<G>>): FrameColumn<G> =
+    DataColumn.createFrameColumn(groups.name, map(body))
+
+// endregion
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/matches.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/matches.kt
new file mode 100644
index 000000000..7b554dc53
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/matches.kt
@@ -0,0 +1,11 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import org.jetbrains.kotlinx.dataframe.DataFrame
+
+// region PivotGroupBy
+
+public fun <T> PivotGroupBy<T>.matches(): DataFrame<T> = matches(yes = true, no = false)
+
+public fun <T, R> PivotGroupBy<T>.matches(yes: R, no: R): DataFrame<T> = aggregate { yes default no }
+
+// endregion
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/max.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/max.kt
new file mode 100644
index 000000000..59b34e856
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/max.kt
@@ -0,0 +1,267 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import org.jetbrains.kotlinx.dataframe.AnyRow
+import org.jetbrains.kotlinx.dataframe.ColumnsSelector
+import org.jetbrains.kotlinx.dataframe.DataColumn
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.DataRow
+import org.jetbrains.kotlinx.dataframe.RowExpression
+import org.jetbrains.kotlinx.dataframe.aggregation.ColumnsForAggregateSelector
+import org.jetbrains.kotlinx.dataframe.columns.ColumnReference
+import org.jetbrains.kotlinx.dataframe.columns.toColumnSet
+import org.jetbrains.kotlinx.dataframe.columns.values
+import org.jetbrains.kotlinx.dataframe.impl.aggregation.aggregators.Aggregators
+import org.jetbrains.kotlinx.dataframe.impl.aggregation.comparableColumns
+import org.jetbrains.kotlinx.dataframe.impl.aggregation.modes.aggregateAll
+import org.jetbrains.kotlinx.dataframe.impl.aggregation.modes.aggregateFor
+import org.jetbrains.kotlinx.dataframe.impl.aggregation.modes.aggregateOfDelegated
+import org.jetbrains.kotlinx.dataframe.impl.columns.toComparableColumns
+import org.jetbrains.kotlinx.dataframe.impl.indexOfMax
+import org.jetbrains.kotlinx.dataframe.impl.suggestIfNull
+import kotlin.reflect.KProperty
+
+// region DataColumn
+
+public fun <T : Comparable<T>> DataColumn<T?>.max(): T = maxOrNull().suggestIfNull("max")
+
+public fun <T : Comparable<T>> DataColumn<T?>.maxOrNull(): T? = asSequence().filterNotNull().maxOrNull()
+
+public fun <T, R : Comparable<R>> DataColumn<T>.maxBy(selector: (T) -> R): T =
+    maxByOrNull(selector).suggestIfNull("maxBy")
+
+public fun <T, R : Comparable<R>> DataColumn<T>.maxByOrNull(selector: (T) -> R): T? = values.maxByOrNull(selector)
+
+public fun <T, R : Comparable<R>> DataColumn<T>.maxOf(selector: (T) -> R): R =
+    maxOfOrNull(selector).suggestIfNull("maxOf")
+
+public fun <T, R : Comparable<R>> DataColumn<T>.maxOfOrNull(selector: (T) -> R): R? = values.maxOfOrNull(selector)
+
+// endregion
+
+// region DataRow
+
+public fun AnyRow.rowMaxOrNull(): Any? = values().filterIsInstance<Comparable<*>>().maxWithOrNull(compareBy { it })
+
+public fun AnyRow.rowMax(): Any = rowMaxOrNull().suggestIfNull("rowMax")
+
+public inline fun <reified T : Comparable<T>> AnyRow.rowMaxOfOrNull(): T? = values().filterIsInstance<T>().maxOrNull()
+
+public inline fun <reified T : Comparable<T>> AnyRow.rowMaxOf(): T = rowMaxOfOrNull<T>().suggestIfNull("rowMaxOf")
+
+// endregion
+
+// region DataFrame
+
+public fun <T> DataFrame<T>.max(): DataRow<T> = maxFor(comparableColumns())
+
+public fun <T, C : Comparable<C>> DataFrame<T>.maxFor(columns: ColumnsForAggregateSelector<T, C?>): DataRow<T> =
+    Aggregators.max.aggregateFor(this, columns)
+
+public fun <T> DataFrame<T>.maxFor(vararg columns: String): DataRow<T> = maxFor { columns.toComparableColumns() }
+
+public fun <T, C : Comparable<C>> DataFrame<T>.maxFor(vararg columns: ColumnReference<C?>): DataRow<T> =
+    maxFor { columns.toColumnSet() }
+
+public fun <T, C : Comparable<C>> DataFrame<T>.maxFor(vararg columns: KProperty<C?>): DataRow<T> =
+    maxFor { columns.toColumnSet() }
+
+public fun <T, C : Comparable<C>> DataFrame<T>.max(columns: ColumnsSelector<T, C?>): C =
+    maxOrNull(columns).suggestIfNull("max")
+
+public fun <T> DataFrame<T>.max(vararg columns: String): Comparable<Any?> = maxOrNull(*columns).suggestIfNull("max")
+
+public fun <T, C : Comparable<C>> DataFrame<T>.max(vararg columns: ColumnReference<C?>): C =
+    maxOrNull(*columns).suggestIfNull("max")
+
+public fun <T, C : Comparable<C>> DataFrame<T>.max(vararg columns: KProperty<C?>): C =
+    maxOrNull(*columns).suggestIfNull("max")
+
+public fun <T, C : Comparable<C>> DataFrame<T>.maxOrNull(columns: ColumnsSelector<T, C?>): C? =
+    Aggregators.max.aggregateAll(this, columns) as C?
+
+public fun <T> DataFrame<T>.maxOrNull(vararg columns: String): Comparable<Any?>? =
+    maxOrNull { columns.toComparableColumns() }
+
+public fun <T, C : Comparable<C>> DataFrame<T>.maxOrNull(vararg columns: ColumnReference<C?>): C? =
+    maxOrNull { columns.toColumnSet() }
+
+public fun <T, C : Comparable<C>> DataFrame<T>.maxOrNull(vararg columns: KProperty<C?>): C? =
+    maxOrNull { columns.toColumnSet() }
+
+public fun <T, C : Comparable<C>> DataFrame<T>.maxOf(expression: RowExpression<T, C>): C =
+    maxOfOrNull(expression).suggestIfNull("maxOf")
+
+public fun <T, C : Comparable<C>> DataFrame<T>.maxOfOrNull(expression: RowExpression<T, C>): C? =
+    rows().maxOfOrNull { expression(it, it) }
+
+public fun <T, C : Comparable<C>> DataFrame<T>.maxBy(expression: RowExpression<T, C?>): DataRow<T> =
+    maxByOrNull(expression).suggestIfNull("maxBy")
+
+public fun <T> DataFrame<T>.maxBy(column: String): DataRow<T> = maxByOrNull(column).suggestIfNull("maxBy")
+
+public fun <T, C : Comparable<C>> DataFrame<T>.maxBy(column: ColumnReference<C?>): DataRow<T> =
+    maxByOrNull(column).suggestIfNull("maxBy")
+
+public fun <T, C : Comparable<C>> DataFrame<T>.maxBy(column: KProperty<C?>): DataRow<T> =
+    maxByOrNull(column).suggestIfNull("maxBy")
+
+public fun <T, C : Comparable<C>> DataFrame<T>.maxByOrNull(expression: RowExpression<T, C?>): DataRow<T>? =
+    getOrNull(rows().asSequence().map { expression(it, it) }.indexOfMax())
+
+public fun <T> DataFrame<T>.maxByOrNull(column: String): DataRow<T>? =
+    maxByOrNull(column.toColumnOf<Comparable<Any?>?>())
+
+public fun <T, C : Comparable<C>> DataFrame<T>.maxByOrNull(column: ColumnReference<C?>): DataRow<T>? =
+    getOrNull(get(column).asSequence().indexOfMax())
+
+public fun <T, C : Comparable<C>> DataFrame<T>.maxByOrNull(column: KProperty<C?>): DataRow<T>? =
+    maxByOrNull(column.toColumnAccessor())
+
+// endregion
+
+// region GroupBy
+
+public fun <T> Grouped<T>.max(): DataFrame<T> = maxFor(comparableColumns())
+
+public fun <T, C : Comparable<C>> Grouped<T>.maxFor(columns: ColumnsForAggregateSelector<T, C?>): DataFrame<T> =
+    Aggregators.max.aggregateFor(this, columns)
+
+public fun <T> Grouped<T>.maxFor(vararg columns: String): DataFrame<T> = maxFor { columns.toComparableColumns() }
+
+public fun <T, C : Comparable<C>> Grouped<T>.maxFor(vararg columns: ColumnReference<C?>): DataFrame<T> =
+    maxFor { columns.toColumnSet() }
+
+public fun <T, C : Comparable<C>> Grouped<T>.maxFor(vararg columns: KProperty<C?>): DataFrame<T> =
+    maxFor { columns.toColumnSet() }
+
+public fun <T, C : Comparable<C>> Grouped<T>.max(name: String? = null, columns: ColumnsSelector<T, C?>): DataFrame<T> =
+    Aggregators.max.aggregateAll(this, name, columns)
+
+public fun <T> Grouped<T>.max(vararg columns: String, name: String? = null): DataFrame<T> =
+    max(name) { columns.toComparableColumns() }
+
+public fun <T, C : Comparable<C>> Grouped<T>.max(
+    vararg columns: ColumnReference<C?>,
+    name: String? = null,
+): DataFrame<T> = max(name) { columns.toColumnSet() }
+
+public fun <T, C : Comparable<C>> Grouped<T>.max(vararg columns: KProperty<C?>, name: String? = null): DataFrame<T> =
+    max(name) { columns.toColumnSet() }
+
+public fun <T, C : Comparable<C>> Grouped<T>.maxOf(
+    name: String? = null,
+    expression: RowExpression<T, C>,
+): DataFrame<T> = Aggregators.max.aggregateOfDelegated(this, name) { maxOfOrNull(expression) }
+
+public fun <T, G, R : Comparable<R>> GroupBy<T, G>.maxBy(rowExpression: RowExpression<G, R?>): ReducedGroupBy<T, G> =
+    reduce { maxByOrNull(rowExpression) }
+
+public fun <T, G, C : Comparable<C>> GroupBy<T, G>.maxBy(column: ColumnReference<C?>): ReducedGroupBy<T, G> =
+    reduce { maxByOrNull(column) }
+
+public fun <T, G> GroupBy<T, G>.maxBy(column: String): ReducedGroupBy<T, G> =
+    maxBy(column.toColumnAccessor().cast<Comparable<Any?>>())
+
+public fun <T, G, C : Comparable<C>> GroupBy<T, G>.maxBy(column: KProperty<C?>): ReducedGroupBy<T, G> =
+    maxBy(column.toColumnAccessor())
+
+// endregion
+
+// region Pivot
+
+public fun <T> Pivot<T>.max(separate: Boolean = false): DataRow<T> = delegate { max(separate) }
+
+public fun <T, R : Comparable<R>> Pivot<T>.maxFor(
+    separate: Boolean = false,
+    columns: ColumnsForAggregateSelector<T, R?>,
+): DataRow<T> = delegate { maxFor(separate, columns) }
+
+public fun <T> Pivot<T>.maxFor(vararg columns: String, separate: Boolean = false): DataRow<T> =
+    maxFor(separate) { columns.toComparableColumns() }
+
+public fun <T, R : Comparable<R>> Pivot<T>.maxFor(
+    vararg columns: ColumnReference<R?>,
+    separate: Boolean = false,
+): DataRow<T> = maxFor(separate) { columns.toColumnSet() }
+
+public fun <T, R : Comparable<R>> Pivot<T>.maxFor(
+    vararg columns: KProperty<R?>,
+    separate: Boolean = false,
+): DataRow<T> = maxFor(separate) { columns.toColumnSet() }
+
+public fun <T, R : Comparable<R>> Pivot<T>.max(columns: ColumnsSelector<T, R?>): DataRow<T> = delegate { max(columns) }
+
+public fun <T> Pivot<T>.max(vararg columns: String): DataRow<T> = max { columns.toComparableColumns() }
+
+public fun <T, R : Comparable<R>> Pivot<T>.max(vararg columns: ColumnReference<R?>): DataRow<T> =
+    max { columns.toColumnSet() }
+
+public fun <T, R : Comparable<R>> Pivot<T>.max(vararg columns: KProperty<R?>): DataRow<T> =
+    max { columns.toColumnSet() }
+
+public fun <T, R : Comparable<R>> Pivot<T>.maxOf(rowExpression: RowExpression<T, R>): DataRow<T> =
+    delegate { maxOf(rowExpression) }
+
+public fun <T, R : Comparable<R>> Pivot<T>.maxBy(rowExpression: RowExpression<T, R>): ReducedPivot<T> =
+    reduce { maxByOrNull(rowExpression) }
+
+public fun <T, C : Comparable<C>> Pivot<T>.maxBy(column: ColumnReference<C?>): ReducedPivot<T> =
+    reduce { maxByOrNull(column) }
+
+public fun <T> Pivot<T>.maxBy(column: String): ReducedPivot<T> =
+    maxBy(column.toColumnAccessor().cast<Comparable<Any?>>())
+
+public fun <T, C : Comparable<C>> Pivot<T>.maxBy(column: KProperty<C?>): ReducedPivot<T> =
+    maxBy(column.toColumnAccessor())
+
+// endregion
+
+// region PivotGroupBy
+
+public fun <T> PivotGroupBy<T>.max(separate: Boolean = false): DataFrame<T> = maxFor(separate, comparableColumns())
+
+public fun <T, R : Comparable<R>> PivotGroupBy<T>.maxFor(
+    separate: Boolean = false,
+    columns: ColumnsForAggregateSelector<T, R?>,
+): DataFrame<T> = Aggregators.max.aggregateFor(this, separate, columns)
+
+public fun <T> PivotGroupBy<T>.maxFor(vararg columns: String, separate: Boolean = false): DataFrame<T> =
+    maxFor(separate) { columns.toComparableColumns() }
+
+public fun <T, R : Comparable<R>> PivotGroupBy<T>.maxFor(
+    vararg columns: ColumnReference<R?>,
+    separate: Boolean = false,
+): DataFrame<T> = maxFor(separate) { columns.toColumnSet() }
+
+public fun <T, R : Comparable<R>> PivotGroupBy<T>.maxFor(
+    vararg columns: KProperty<R?>,
+    separate: Boolean = false,
+): DataFrame<T> = maxFor(separate) { columns.toColumnSet() }
+
+public fun <T, R : Comparable<R>> PivotGroupBy<T>.max(columns: ColumnsSelector<T, R?>): DataFrame<T> =
+    Aggregators.max.aggregateAll(this, columns)
+
+public fun <T> PivotGroupBy<T>.max(vararg columns: String): DataFrame<T> = max { columns.toComparableColumns() }
+
+public fun <T, R : Comparable<R>> PivotGroupBy<T>.max(vararg columns: ColumnReference<R?>): DataFrame<T> =
+    max { columns.toColumnSet() }
+
+public fun <T, R : Comparable<R>> PivotGroupBy<T>.max(vararg columns: KProperty<R?>): DataFrame<T> =
+    max { columns.toColumnSet() }
+
+public fun <T, R : Comparable<R>> PivotGroupBy<T>.maxOf(rowExpression: RowExpression<T, R>): DataFrame<T> =
+    aggregate { maxOf(rowExpression) }
+
+public fun <T, R : Comparable<R>> PivotGroupBy<T>.maxBy(rowExpression: RowExpression<T, R>): ReducedPivotGroupBy<T> =
+    reduce { maxByOrNull(rowExpression) }
+
+public fun <T, C : Comparable<C>> PivotGroupBy<T>.maxBy(column: ColumnReference<C?>): ReducedPivotGroupBy<T> =
+    reduce { maxByOrNull(column) }
+
+public fun <T> PivotGroupBy<T>.maxBy(column: String): ReducedPivotGroupBy<T> =
+    maxBy(column.toColumnAccessor().cast<Comparable<Any?>>())
+
+public fun <T, C : Comparable<C>> PivotGroupBy<T>.maxBy(column: KProperty<C?>): ReducedPivotGroupBy<T> =
+    maxBy(column.toColumnAccessor())
+
+// endregion
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/mean.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/mean.kt
new file mode 100644
index 000000000..81309e7d7
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/mean.kt
@@ -0,0 +1,242 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import org.jetbrains.kotlinx.dataframe.AnyRow
+import org.jetbrains.kotlinx.dataframe.ColumnsSelector
+import org.jetbrains.kotlinx.dataframe.DataColumn
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.DataRow
+import org.jetbrains.kotlinx.dataframe.RowExpression
+import org.jetbrains.kotlinx.dataframe.aggregation.ColumnsForAggregateSelector
+import org.jetbrains.kotlinx.dataframe.columns.ColumnReference
+import org.jetbrains.kotlinx.dataframe.columns.toColumnSet
+import org.jetbrains.kotlinx.dataframe.columns.toColumnsSetOf
+import org.jetbrains.kotlinx.dataframe.impl.aggregation.aggregators.Aggregators
+import org.jetbrains.kotlinx.dataframe.impl.aggregation.aggregators.cast2
+import org.jetbrains.kotlinx.dataframe.impl.aggregation.modes.aggregateAll
+import org.jetbrains.kotlinx.dataframe.impl.aggregation.modes.aggregateFor
+import org.jetbrains.kotlinx.dataframe.impl.aggregation.modes.aggregateOf
+import org.jetbrains.kotlinx.dataframe.impl.aggregation.modes.of
+import org.jetbrains.kotlinx.dataframe.impl.aggregation.numberColumns
+import org.jetbrains.kotlinx.dataframe.impl.columns.toNumberColumns
+import org.jetbrains.kotlinx.dataframe.impl.suggestIfNull
+import org.jetbrains.kotlinx.dataframe.math.mean
+import kotlin.reflect.KProperty
+import kotlin.reflect.typeOf
+
+// region DataColumn
+
+public fun <T : Number> DataColumn<T?>.mean(skipNA: Boolean = skipNA_default): Double =
+    meanOrNull(skipNA).suggestIfNull("mean")
+
+public fun <T : Number> DataColumn<T?>.meanOrNull(skipNA: Boolean = skipNA_default): Double? =
+    Aggregators.mean(skipNA).aggregate(this)
+
+public inline fun <T, reified R : Number> DataColumn<T>.meanOf(
+    skipNA: Boolean = skipNA_default,
+    noinline expression: (T) -> R?,
+): Double = Aggregators.mean(skipNA).cast2<R?, Double>().aggregateOf(this, expression) ?: Double.NaN
+
+// endregion
+
+// region DataRow
+
+public fun AnyRow.rowMean(skipNA: Boolean = skipNA_default): Double =
+    values().filterIsInstance<Number>().map { it.toDouble() }.mean(skipNA)
+
+public inline fun <reified T : Number> AnyRow.rowMeanOf(): Double = values().filterIsInstance<T>().mean(typeOf<T>())
+
+// endregion
+
+// region DataFrame
+
+public fun <T> DataFrame<T>.mean(skipNA: Boolean = skipNA_default): DataRow<T> = meanFor(skipNA, numberColumns())
+
+public fun <T, C : Number> DataFrame<T>.meanFor(
+    skipNA: Boolean = skipNA_default,
+    columns: ColumnsForAggregateSelector<T, C?>,
+): DataRow<T> = Aggregators.mean(skipNA).aggregateFor(this, columns)
+
+public fun <T> DataFrame<T>.meanFor(vararg columns: String, skipNA: Boolean = skipNA_default): DataRow<T> =
+    meanFor(skipNA) { columns.toNumberColumns() }
+
+public fun <T, C : Number> DataFrame<T>.meanFor(
+    vararg columns: ColumnReference<C?>,
+    skipNA: Boolean = skipNA_default,
+): DataRow<T> = meanFor(skipNA) { columns.toColumnSet() }
+
+public fun <T, C : Number> DataFrame<T>.meanFor(
+    vararg columns: KProperty<C?>,
+    skipNA: Boolean = skipNA_default,
+): DataRow<T> = meanFor(skipNA) { columns.toColumnSet() }
+
+public fun <T, C : Number> DataFrame<T>.mean(
+    skipNA: Boolean = skipNA_default,
+    columns: ColumnsSelector<T, C?>,
+): Double = Aggregators.mean(skipNA).aggregateAll(this, columns) as Double? ?: Double.NaN
+
+public fun <T> DataFrame<T>.mean(vararg columns: String, skipNA: Boolean = skipNA_default): Double =
+    mean(skipNA) { columns.toNumberColumns() }
+
+public fun <T, C : Number> DataFrame<T>.mean(
+    vararg columns: ColumnReference<C?>,
+    skipNA: Boolean = skipNA_default,
+): Double = mean(skipNA) { columns.toColumnSet() }
+
+public fun <T, C : Number> DataFrame<T>.mean(vararg columns: KProperty<C?>, skipNA: Boolean = skipNA_default): Double =
+    mean(skipNA) { columns.toColumnSet() }
+
+public inline fun <T, reified D : Number> DataFrame<T>.meanOf(
+    skipNA: Boolean = skipNA_default,
+    noinline expression: RowExpression<T, D?>,
+): Double = Aggregators.mean(skipNA).of(this, expression) ?: Double.NaN
+
+// endregion
+
+// region GroupBy
+
+public fun <T> Grouped<T>.mean(skipNA: Boolean = skipNA_default): DataFrame<T> = meanFor(skipNA, numberColumns())
+
+public fun <T, C : Number> Grouped<T>.meanFor(
+    skipNA: Boolean = skipNA_default,
+    columns: ColumnsForAggregateSelector<T, C?>,
+): DataFrame<T> = Aggregators.mean(skipNA).aggregateFor(this, columns)
+
+public fun <T> Grouped<T>.meanFor(vararg columns: String, skipNA: Boolean = skipNA_default): DataFrame<T> =
+    meanFor(skipNA) { columns.toNumberColumns() }
+
+public fun <T, C : Number> Grouped<T>.meanFor(
+    vararg columns: ColumnReference<C?>,
+    skipNA: Boolean = skipNA_default,
+): DataFrame<T> = meanFor(skipNA) { columns.toColumnSet() }
+
+public fun <T, C : Number> Grouped<T>.meanFor(
+    vararg columns: KProperty<C?>,
+    skipNA: Boolean = skipNA_default,
+): DataFrame<T> = meanFor(skipNA) { columns.toColumnSet() }
+
+public fun <T, C : Number> Grouped<T>.mean(
+    name: String? = null,
+    skipNA: Boolean = skipNA_default,
+    columns: ColumnsSelector<T, C?>,
+): DataFrame<T> = Aggregators.mean(skipNA).aggregateAll(this, name, columns)
+
+public fun <T> Grouped<T>.mean(
+    vararg columns: String,
+    name: String? = null,
+    skipNA: Boolean = skipNA_default,
+): DataFrame<T> = mean(name, skipNA) { columns.toNumberColumns() }
+
+public fun <T, C : Number> Grouped<T>.mean(
+    vararg columns: ColumnReference<C?>,
+    name: String? = null,
+    skipNA: Boolean = skipNA_default,
+): DataFrame<T> = mean(name, skipNA) { columns.toColumnSet() }
+
+public fun <T, C : Number> Grouped<T>.mean(
+    vararg columns: KProperty<C?>,
+    name: String? = null,
+    skipNA: Boolean = skipNA_default,
+): DataFrame<T> = mean(name, skipNA) { columns.toColumnSet() }
+
+public inline fun <T, reified R : Number> Grouped<T>.meanOf(
+    name: String? = null,
+    skipNA: Boolean = skipNA_default,
+    crossinline expression: RowExpression<T, R?>,
+): DataFrame<T> = Aggregators.mean(skipNA).aggregateOf(this, name, expression)
+
+// endregion
+
+// region Pivot
+
+public fun <T> Pivot<T>.mean(skipNA: Boolean = skipNA_default, separate: Boolean = false): DataRow<T> =
+    meanFor(skipNA, separate, numberColumns())
+
+public fun <T, C : Number> Pivot<T>.meanFor(
+    skipNA: Boolean = skipNA_default,
+    separate: Boolean = false,
+    columns: ColumnsForAggregateSelector<T, C?>,
+): DataRow<T> = delegate { meanFor(skipNA, separate, columns) }
+
+public fun <T> Pivot<T>.meanFor(
+    vararg columns: String,
+    skipNA: Boolean = skipNA_default,
+    separate: Boolean = false,
+): DataRow<T> = meanFor(skipNA, separate) { columns.toNumberColumns() }
+
+public fun <T, C : Number> Pivot<T>.meanFor(
+    vararg columns: ColumnReference<C?>,
+    skipNA: Boolean = skipNA_default,
+    separate: Boolean = false,
+): DataRow<T> = meanFor(skipNA, separate) { columns.toColumnSet() }
+
+public fun <T, C : Number> Pivot<T>.meanFor(
+    vararg columns: KProperty<C?>,
+    skipNA: Boolean = skipNA_default,
+    separate: Boolean = false,
+): DataRow<T> = meanFor(skipNA, separate) { columns.toColumnSet() }
+
+public fun <T, R : Number> Pivot<T>.mean(
+    skipNA: Boolean = skipNA_default,
+    columns: ColumnsSelector<T, R?>,
+): DataRow<T> = delegate { mean(skipNA, columns) }
+
+public inline fun <T, reified R : Number> Pivot<T>.meanOf(
+    skipNA: Boolean = skipNA_default,
+    crossinline expression: RowExpression<T, R?>,
+): DataRow<T> = delegate { meanOf(skipNA, expression) }
+
+// endregion
+
+// region PivotGroupBy
+
+public fun <T> PivotGroupBy<T>.mean(separate: Boolean = false, skipNA: Boolean = skipNA_default): DataFrame<T> =
+    meanFor(skipNA, separate, numberColumns())
+
+public fun <T, C : Number> PivotGroupBy<T>.meanFor(
+    skipNA: Boolean = skipNA_default,
+    separate: Boolean = false,
+    columns: ColumnsForAggregateSelector<T, C?>,
+): DataFrame<T> = Aggregators.mean(skipNA).aggregateFor(this, separate, columns)
+
+public fun <T> PivotGroupBy<T>.meanFor(
+    vararg columns: String,
+    separate: Boolean = false,
+    skipNA: Boolean = skipNA_default,
+): DataFrame<T> = meanFor(skipNA, separate) { columns.toNumberColumns() }
+
+public fun <T, C : Number> PivotGroupBy<T>.meanFor(
+    vararg columns: ColumnReference<C?>,
+    separate: Boolean = false,
+    skipNA: Boolean = skipNA_default,
+): DataFrame<T> = meanFor(skipNA, separate) { columns.toColumnSet() }
+
+public fun <T, C : Number> PivotGroupBy<T>.meanFor(
+    vararg columns: KProperty<C?>,
+    separate: Boolean = false,
+    skipNA: Boolean = skipNA_default,
+): DataFrame<T> = meanFor(skipNA, separate) { columns.toColumnSet() }
+
+public fun <T, R : Number> PivotGroupBy<T>.mean(
+    skipNA: Boolean = skipNA_default,
+    columns: ColumnsSelector<T, R?>,
+): DataFrame<T> = Aggregators.mean(skipNA).aggregateAll(this, columns)
+
+public fun <T> PivotGroupBy<T>.mean(vararg columns: String, skipNA: Boolean = skipNA_default): DataFrame<T> =
+    mean(skipNA) { columns.toColumnsSetOf() }
+
+public fun <T, R : Number> PivotGroupBy<T>.mean(
+    vararg columns: ColumnReference<R?>,
+    skipNA: Boolean = skipNA_default,
+): DataFrame<T> = mean(skipNA) { columns.toColumnSet() }
+
+public fun <T, R : Number> PivotGroupBy<T>.mean(
+    vararg columns: KProperty<R?>,
+    skipNA: Boolean = skipNA_default,
+): DataFrame<T> = mean(skipNA) { columns.toColumnSet() }
+
+public inline fun <T, reified R : Number> PivotGroupBy<T>.meanOf(
+    skipNA: Boolean = skipNA_default,
+    crossinline expression: RowExpression<T, R?>,
+): DataFrame<T> = Aggregators.mean(skipNA).aggregateOf(this, expression)
+
+// endregion
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/median.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/median.kt
new file mode 100644
index 000000000..fb57e33d7
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/median.kt
@@ -0,0 +1,212 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import org.jetbrains.kotlinx.dataframe.AnyRow
+import org.jetbrains.kotlinx.dataframe.ColumnsSelector
+import org.jetbrains.kotlinx.dataframe.DataColumn
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.DataRow
+import org.jetbrains.kotlinx.dataframe.RowExpression
+import org.jetbrains.kotlinx.dataframe.aggregation.ColumnsForAggregateSelector
+import org.jetbrains.kotlinx.dataframe.columns.ColumnReference
+import org.jetbrains.kotlinx.dataframe.columns.toColumnSet
+import org.jetbrains.kotlinx.dataframe.impl.aggregation.aggregators.Aggregators
+import org.jetbrains.kotlinx.dataframe.impl.aggregation.aggregators.cast
+import org.jetbrains.kotlinx.dataframe.impl.aggregation.comparableColumns
+import org.jetbrains.kotlinx.dataframe.impl.aggregation.modes.aggregateAll
+import org.jetbrains.kotlinx.dataframe.impl.aggregation.modes.aggregateFor
+import org.jetbrains.kotlinx.dataframe.impl.aggregation.modes.aggregateOf
+import org.jetbrains.kotlinx.dataframe.impl.aggregation.modes.of
+import org.jetbrains.kotlinx.dataframe.impl.columns.toComparableColumns
+import org.jetbrains.kotlinx.dataframe.impl.suggestIfNull
+import org.jetbrains.kotlinx.dataframe.math.medianOrNull
+import kotlin.reflect.KProperty
+
+// region DataColumn
+
+public fun <T : Comparable<T>> DataColumn<T?>.median(): T = medianOrNull().suggestIfNull("median")
+
+public fun <T : Comparable<T>> DataColumn<T?>.medianOrNull(): T? = Aggregators.median.cast<T>().aggregate(this)
+
+public inline fun <T, reified R : Comparable<R>> DataColumn<T>.medianOfOrNull(noinline expression: (T) -> R?): R? =
+    Aggregators.median.cast<R?>().aggregateOf(this, expression)
+
+public inline fun <T, reified R : Comparable<R>> DataColumn<T>.medianOf(noinline expression: (T) -> R?): R =
+    medianOfOrNull(expression).suggestIfNull("medianOf")
+
+// endregion
+
+// region DataRow
+
+public fun AnyRow.rowMedianOrNull(): Any? =
+    Aggregators.median.aggregateMixed(
+        values().filterIsInstance<Comparable<Any?>>().asIterable(),
+    )
+
+public fun AnyRow.rowMedian(): Any = rowMedianOrNull().suggestIfNull("rowMedian")
+
+public inline fun <reified T : Comparable<T>> AnyRow.rowMedianOfOrNull(): T? = valuesOf<T>().medianOrNull()
+
+public inline fun <reified T : Comparable<T>> AnyRow.rowMedianOf(): T =
+    rowMedianOfOrNull<T>().suggestIfNull("rowMedianOf")
+
+// endregion
+
+// region DataFrame
+
+public fun <T> DataFrame<T>.median(): DataRow<T> = medianFor(comparableColumns())
+
+public fun <T, C : Comparable<C>> DataFrame<T>.medianFor(columns: ColumnsForAggregateSelector<T, C?>): DataRow<T> =
+    Aggregators.median.aggregateFor(this, columns)
+
+public fun <T> DataFrame<T>.medianFor(vararg columns: String): DataRow<T> = medianFor { columns.toComparableColumns() }
+
+public fun <T, C : Comparable<C>> DataFrame<T>.medianFor(vararg columns: ColumnReference<C?>): DataRow<T> =
+    medianFor { columns.toColumnSet() }
+
+public fun <T, C : Comparable<C>> DataFrame<T>.medianFor(vararg columns: KProperty<C?>): DataRow<T> =
+    medianFor { columns.toColumnSet() }
+
+public fun <T, C : Comparable<C>> DataFrame<T>.median(columns: ColumnsSelector<T, C?>): C =
+    medianOrNull(columns).suggestIfNull("median")
+
+public fun <T> DataFrame<T>.median(vararg columns: String): Any = median { columns.toComparableColumns() }
+
+public fun <T, C : Comparable<C>> DataFrame<T>.median(vararg columns: ColumnReference<C?>): C =
+    median { columns.toColumnSet() }
+
+public fun <T, C : Comparable<C>> DataFrame<T>.median(vararg columns: KProperty<C?>): C =
+    median { columns.toColumnSet() }
+
+public fun <T, C : Comparable<C>> DataFrame<T>.medianOrNull(columns: ColumnsSelector<T, C?>): C? =
+    Aggregators.median.aggregateAll(this, columns) as C?
+
+public fun <T> DataFrame<T>.medianOrNull(vararg columns: String): Any? = medianOrNull { columns.toComparableColumns() }
+
+public fun <T, C : Comparable<C>> DataFrame<T>.medianOrNull(vararg columns: ColumnReference<C?>): C? =
+    medianOrNull { columns.toColumnSet() }
+
+public fun <T, C : Comparable<C>> DataFrame<T>.medianOrNull(vararg columns: KProperty<C?>): C? =
+    medianOrNull { columns.toColumnSet() }
+
+public inline fun <T, reified R : Comparable<R>> DataFrame<T>.medianOf(
+    crossinline expression: RowExpression<T, R?>,
+): R? = Aggregators.median.of(this, expression) as R?
+
+// endregion
+
+// region GroupBy
+
+public fun <T> Grouped<T>.median(): DataFrame<T> = medianFor(comparableColumns())
+
+public fun <T, C : Comparable<C>> Grouped<T>.medianFor(columns: ColumnsForAggregateSelector<T, C?>): DataFrame<T> =
+    Aggregators.median.aggregateFor(this, columns)
+
+public fun <T> Grouped<T>.medianFor(vararg columns: String): DataFrame<T> = medianFor { columns.toComparableColumns() }
+
+public fun <T, C : Comparable<C>> Grouped<T>.medianFor(vararg columns: ColumnReference<C?>): DataFrame<T> =
+    medianFor { columns.toColumnSet() }
+
+public fun <T, C : Comparable<C>> Grouped<T>.medianFor(vararg columns: KProperty<C?>): DataFrame<T> =
+    medianFor { columns.toColumnSet() }
+
+public fun <T, C : Comparable<C>> Grouped<T>.median(
+    name: String? = null,
+    columns: ColumnsSelector<T, C?>,
+): DataFrame<T> = Aggregators.median.aggregateAll(this, name, columns)
+
+public fun <T> Grouped<T>.median(vararg columns: String, name: String? = null): DataFrame<T> =
+    median(name) { columns.toComparableColumns() }
+
+public fun <T, C : Comparable<C>> Grouped<T>.median(
+    vararg columns: ColumnReference<C?>,
+    name: String? = null,
+): DataFrame<T> = median(name) { columns.toColumnSet() }
+
+public fun <T, C : Comparable<C>> Grouped<T>.median(vararg columns: KProperty<C?>, name: String? = null): DataFrame<T> =
+    median(name) { columns.toColumnSet() }
+
+public inline fun <T, reified R : Comparable<R>> Grouped<T>.medianOf(
+    name: String? = null,
+    crossinline expression: RowExpression<T, R?>,
+): DataFrame<T> = Aggregators.median.aggregateOf(this, name, expression)
+
+// endregion
+
+// region Pivot
+
+public fun <T> Pivot<T>.median(separate: Boolean = false): DataRow<T> = medianFor(separate, comparableColumns())
+
+public fun <T, C : Comparable<C>> Pivot<T>.medianFor(
+    separate: Boolean = false,
+    columns: ColumnsForAggregateSelector<T, C?>,
+): DataRow<T> = delegate { medianFor(separate, columns) }
+
+public fun <T> Pivot<T>.medianFor(vararg columns: String, separate: Boolean = false): DataRow<T> =
+    medianFor(separate) { columns.toComparableColumns() }
+
+public fun <T, C : Comparable<C>> Pivot<T>.medianFor(
+    vararg columns: ColumnReference<C?>,
+    separate: Boolean = false,
+): DataRow<T> = medianFor(separate) { columns.toColumnSet() }
+
+public fun <T, C : Comparable<C>> Pivot<T>.medianFor(
+    vararg columns: KProperty<C?>,
+    separate: Boolean = false,
+): DataRow<T> = medianFor(separate) { columns.toColumnSet() }
+
+public fun <T, C : Comparable<C>> Pivot<T>.median(columns: ColumnsSelector<T, C?>): DataRow<T> =
+    delegate { median(columns) }
+
+public fun <T> Pivot<T>.median(vararg columns: String): DataRow<T> = median { columns.toComparableColumns() }
+
+public fun <T, C : Comparable<C>> Pivot<T>.median(vararg columns: ColumnReference<C?>): DataRow<T> =
+    median { columns.toColumnSet() }
+
+public fun <T, C : Comparable<C>> Pivot<T>.median(vararg columns: KProperty<C?>): DataRow<T> =
+    median { columns.toColumnSet() }
+
+public inline fun <T, reified R : Comparable<R>> Pivot<T>.medianOf(
+    crossinline expression: RowExpression<T, R?>,
+): DataRow<T> = delegate { medianOf(expression) }
+
+// endregion
+
+// region PivotGroupBy
+
+public fun <T> PivotGroupBy<T>.median(separate: Boolean = false): DataFrame<T> =
+    medianFor(separate, comparableColumns())
+
+public fun <T, C : Comparable<C>> PivotGroupBy<T>.medianFor(
+    separate: Boolean = false,
+    columns: ColumnsForAggregateSelector<T, C?>,
+): DataFrame<T> = Aggregators.median.aggregateFor(this, separate, columns)
+
+public fun <T> PivotGroupBy<T>.medianFor(vararg columns: String, separate: Boolean = false): DataFrame<T> =
+    medianFor(separate) { columns.toComparableColumns() }
+
+public fun <T, C : Comparable<C>> PivotGroupBy<T>.medianFor(
+    vararg columns: ColumnReference<C?>,
+    separate: Boolean = false,
+): DataFrame<T> = medianFor(separate) { columns.toColumnSet() }
+
+public fun <T, C : Comparable<C>> PivotGroupBy<T>.medianFor(
+    vararg columns: KProperty<C?>,
+    separate: Boolean = false,
+): DataFrame<T> = medianFor(separate) { columns.toColumnSet() }
+
+public fun <T, C : Comparable<C>> PivotGroupBy<T>.median(columns: ColumnsSelector<T, C?>): DataFrame<T> =
+    Aggregators.median.aggregateAll(this, columns)
+
+public fun <T> PivotGroupBy<T>.median(vararg columns: String): DataFrame<T> = median { columns.toComparableColumns() }
+
+public fun <T, C : Comparable<C>> PivotGroupBy<T>.median(vararg columns: ColumnReference<C?>): DataFrame<T> =
+    median { columns.toColumnSet() }
+
+public fun <T, C : Comparable<C>> PivotGroupBy<T>.median(vararg columns: KProperty<C?>): DataFrame<T> =
+    median { columns.toColumnSet() }
+
+public inline fun <T, reified R : Comparable<R>> PivotGroupBy<T>.medianOf(
+    crossinline expression: RowExpression<T, R?>,
+): DataFrame<T> = Aggregators.median.aggregateOf(this, expression)
+
+// endregion
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/merge.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/merge.kt
new file mode 100644
index 000000000..1dd19d24c
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/merge.kt
@@ -0,0 +1,110 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import org.jetbrains.kotlinx.dataframe.AnyRow
+import org.jetbrains.kotlinx.dataframe.ColumnsSelector
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.DataRow
+import org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor
+import org.jetbrains.kotlinx.dataframe.columns.ColumnPath
+import org.jetbrains.kotlinx.dataframe.columns.ColumnReference
+import org.jetbrains.kotlinx.dataframe.columns.toColumnSet
+import org.jetbrains.kotlinx.dataframe.impl.api.removeImpl
+import org.jetbrains.kotlinx.dataframe.impl.api.withRowCellImpl
+import org.jetbrains.kotlinx.dataframe.impl.nameGenerator
+import kotlin.reflect.KProperty
+import kotlin.reflect.KType
+import kotlin.reflect.typeOf
+
+public fun <T, C> DataFrame<T>.merge(selector: ColumnsSelector<T, C>): Merge<T, C, List<C>> =
+    Merge(this, selector, false, { it }, typeOf<Any?>(), Infer.Type)
+
+public fun <T> DataFrame<T>.merge(vararg columns: String): Merge<T, Any?, List<Any?>> = merge { columns.toColumnSet() }
+
+public inline fun <T, reified C> DataFrame<T>.merge(vararg columns: ColumnReference<C>): Merge<T, C, List<C>> =
+    merge { columns.toColumnSet() }
+
+public inline fun <T, reified C> DataFrame<T>.merge(vararg columns: KProperty<C>): Merge<T, C, List<C>> =
+    merge { columns.toColumnSet() }
+
+public data class Merge<T, C, R>(
+    @PublishedApi
+    internal val df: DataFrame<T>,
+    @PublishedApi
+    internal val selector: ColumnsSelector<T, C>,
+    @PublishedApi
+    internal val notNull: Boolean,
+    @PublishedApi
+    internal val transform: DataRow<T>.(List<C>) -> R,
+    @PublishedApi
+    internal val resultType: KType,
+    @PublishedApi
+    internal val infer: Infer,
+)
+
+public fun <T, C, R> Merge<T, C, R>.notNull(): Merge<T, C, R> = copy(notNull = true)
+
+public fun <T, C, R> Merge<T, C, R>.into(columnName: String): DataFrame<T> = into(pathOf(columnName))
+
+public fun <T, C, R> Merge<T, C, R>.into(column: ColumnAccessor<*>): DataFrame<T> = into(column.path())
+
+public fun <T, C, R> Merge<T, C, R>.intoList(): List<R> =
+    df.select(selector).rows().map { transform(it, it.values() as List<C>) }
+
+public fun <T, C, R> Merge<T, C, R>.into(path: ColumnPath): DataFrame<T> {
+    // If target path exists, merge into temp path
+    val mergePath = if (df.getColumnOrNull(path) != null) pathOf(nameGenerator().addUnique("temp")) else path
+
+    // move columns into group
+    val grouped = df.move(selector).under { mergePath }
+
+    var res = grouped.convert { getColumnGroup(mergePath) }.withRowCellImpl(resultType, infer) {
+        val srcRow = df[index()]
+        var values = it.values() as List<C>
+        if (notNull) {
+            values = values.filter {
+                it != null && (it !is AnyRow || !it.isEmpty())
+            }
+        }
+        transform(srcRow, values)
+    }
+    if (mergePath != path) {
+        // target path existed before merge, but
+        // it may have already been removed
+        res = res
+            .removeImpl(allowMissingColumns = true) { path }
+            .df
+            .move(mergePath).into { path }
+    }
+    return res
+}
+
+public fun <T, C, R> Merge<T, C, R>.asStrings(): Merge<T, C, String> = by(", ")
+
+public fun <T, C, R> Merge<T, C, R>.by(
+    separator: CharSequence = ", ",
+    prefix: CharSequence = "",
+    postfix: CharSequence = "",
+    limit: Int = -1,
+    truncated: CharSequence = "...",
+): Merge<T, C, String> =
+    Merge(
+        df = df,
+        selector = selector,
+        notNull = notNull,
+        transform = {
+            it.joinToString(
+                separator = separator,
+                prefix = prefix,
+                postfix = postfix,
+                limit = limit,
+                truncated = truncated,
+            )
+        },
+        resultType = typeOf<String>(),
+        infer = Infer.Nulls,
+    )
+
+public inline fun <T, C, R, reified V> Merge<T, C, R>.by(
+    infer: Infer = Infer.Nulls,
+    crossinline transform: DataRow<T>.(R) -> V,
+): Merge<T, C, V> = Merge(df, selector, notNull, { transform(this@by.transform(this, it)) }, typeOf<V>(), infer)
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/min.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/min.kt
new file mode 100644
index 000000000..2ec4be894
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/min.kt
@@ -0,0 +1,268 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import org.jetbrains.kotlinx.dataframe.AnyRow
+import org.jetbrains.kotlinx.dataframe.ColumnsSelector
+import org.jetbrains.kotlinx.dataframe.DataColumn
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.DataRow
+import org.jetbrains.kotlinx.dataframe.RowExpression
+import org.jetbrains.kotlinx.dataframe.aggregation.ColumnsForAggregateSelector
+import org.jetbrains.kotlinx.dataframe.columns.ColumnReference
+import org.jetbrains.kotlinx.dataframe.columns.toColumnSet
+import org.jetbrains.kotlinx.dataframe.columns.values
+import org.jetbrains.kotlinx.dataframe.impl.aggregation.aggregators.Aggregators
+import org.jetbrains.kotlinx.dataframe.impl.aggregation.comparableColumns
+import org.jetbrains.kotlinx.dataframe.impl.aggregation.modes.aggregateAll
+import org.jetbrains.kotlinx.dataframe.impl.aggregation.modes.aggregateFor
+import org.jetbrains.kotlinx.dataframe.impl.aggregation.modes.aggregateOfDelegated
+import org.jetbrains.kotlinx.dataframe.impl.columns.toComparableColumns
+import org.jetbrains.kotlinx.dataframe.impl.indexOfMin
+import org.jetbrains.kotlinx.dataframe.impl.suggestIfNull
+import kotlin.reflect.KProperty
+
+// region DataColumn
+
+public fun <T : Comparable<T>> DataColumn<T?>.min(): T = minOrNull().suggestIfNull("min")
+
+public fun <T : Comparable<T>> DataColumn<T?>.minOrNull(): T? = asSequence().filterNotNull().minOrNull()
+
+public fun <T, R : Comparable<R>> DataColumn<T>.minBy(selector: (T) -> R): T =
+    minByOrNull(selector).suggestIfNull("minBy")
+
+public fun <T, R : Comparable<R>> DataColumn<T>.minByOrNull(selector: (T) -> R): T? = values.minByOrNull(selector)
+
+public fun <T, R : Comparable<R>> DataColumn<T>.minOf(selector: (T) -> R): R =
+    minOfOrNull(selector).suggestIfNull("minOf")
+
+public fun <T, R : Comparable<R>> DataColumn<T>.minOfOrNull(selector: (T) -> R): R? = values.minOfOrNull(selector)
+
+// endregion
+
+// region DataRow
+
+public fun AnyRow.rowMinOrNull(): Any? = values().filterIsInstance<Comparable<*>>().minWithOrNull(compareBy { it })
+
+public fun AnyRow.rowMin(): Any = rowMinOrNull().suggestIfNull("rowMin")
+
+public inline fun <reified T : Comparable<T>> AnyRow.rowMinOfOrNull(): T? = values().filterIsInstance<T>().minOrNull()
+
+public inline fun <reified T : Comparable<T>> AnyRow.rowMinOf(): T = rowMinOfOrNull<T>().suggestIfNull("rowMinOf")
+
+// endregion
+
+// region DataFrame
+
+public fun <T> DataFrame<T>.min(): DataRow<T> = minFor(comparableColumns())
+
+public fun <T, C : Comparable<C>> DataFrame<T>.minFor(columns: ColumnsForAggregateSelector<T, C?>): DataRow<T> =
+    Aggregators.min.aggregateFor(this, columns)
+
+public fun <T> DataFrame<T>.minFor(vararg columns: String): DataRow<T> = minFor { columns.toComparableColumns() }
+
+public fun <T, C : Comparable<C>> DataFrame<T>.minFor(vararg columns: ColumnReference<C?>): DataRow<T> =
+    minFor { columns.toColumnSet() }
+
+public fun <T, C : Comparable<C>> DataFrame<T>.minFor(vararg columns: KProperty<C?>): DataRow<T> =
+    minFor { columns.toColumnSet() }
+
+public fun <T, C : Comparable<C>> DataFrame<T>.min(columns: ColumnsSelector<T, C?>): C =
+    minOrNull(columns).suggestIfNull("min")
+
+public fun <T> DataFrame<T>.min(vararg columns: String): Comparable<Any> = minOrNull(*columns).suggestIfNull("min")
+
+public fun <T, C : Comparable<C>> DataFrame<T>.min(vararg columns: ColumnReference<C?>): C =
+    minOrNull(*columns).suggestIfNull("min")
+
+public fun <T, C : Comparable<C>> DataFrame<T>.min(vararg columns: KProperty<C?>): C =
+    minOrNull(*columns).suggestIfNull("min")
+
+public fun <T, C : Comparable<C>> DataFrame<T>.minOrNull(columns: ColumnsSelector<T, C?>): C? =
+    Aggregators.min.aggregateAll(this, columns) as C?
+
+public fun <T> DataFrame<T>.minOrNull(vararg columns: String): Comparable<Any?>? =
+    minOrNull { columns.toComparableColumns() }
+
+public fun <T, C : Comparable<C>> DataFrame<T>.minOrNull(vararg columns: ColumnReference<C?>): C? =
+    minOrNull { columns.toColumnSet() }
+
+public fun <T, C : Comparable<C>> DataFrame<T>.minOrNull(vararg columns: KProperty<C?>): C? =
+    minOrNull { columns.toColumnSet() }
+
+public fun <T, C : Comparable<C>> DataFrame<T>.minOf(expression: RowExpression<T, C>): C =
+    minOfOrNull(expression).suggestIfNull("minOf")
+
+public fun <T, C : Comparable<C>> DataFrame<T>.minOfOrNull(expression: RowExpression<T, C>): C? =
+    rows().minOfOrNull { expression(it, it) }
+
+public fun <T, C : Comparable<C>> DataFrame<T>.minBy(expression: RowExpression<T, C?>): DataRow<T> =
+    minByOrNull(expression).suggestIfNull("minBy")
+
+public fun <T> DataFrame<T>.minBy(column: String): DataRow<T> = minByOrNull(column).suggestIfNull("minBy")
+
+public fun <T, C : Comparable<C>> DataFrame<T>.minBy(column: ColumnReference<C?>): DataRow<T> =
+    minByOrNull(column).suggestIfNull("minBy")
+
+public fun <T, C : Comparable<C>> DataFrame<T>.minBy(column: KProperty<C?>): DataRow<T> =
+    minByOrNull(column).suggestIfNull("minBy")
+
+public fun <T, C : Comparable<C>> DataFrame<T>.minByOrNull(expression: RowExpression<T, C?>): DataRow<T>? =
+    getOrNull(rows().asSequence().map { expression(it, it) }.indexOfMin())
+
+public fun <T> DataFrame<T>.minByOrNull(column: String): DataRow<T>? =
+    minByOrNull(column.toColumnOf<Comparable<Any?>?>())
+
+public fun <T, C : Comparable<C>> DataFrame<T>.minByOrNull(column: ColumnReference<C?>): DataRow<T>? =
+    getOrNull(get(column).asSequence().indexOfMin())
+
+public fun <T, C : Comparable<C>> DataFrame<T>.minByOrNull(column: KProperty<C?>): DataRow<T>? =
+    minByOrNull(column.toColumnAccessor())
+
+// endregion
+
+// region GroupBy
+
+public fun <T> Grouped<T>.min(): DataFrame<T> = minFor(comparableColumns())
+
+public fun <T, C : Comparable<C>> Grouped<T>.minFor(columns: ColumnsForAggregateSelector<T, C?>): DataFrame<T> =
+    Aggregators.min.aggregateFor(this, columns)
+
+public fun <T> Grouped<T>.minFor(vararg columns: String): DataFrame<T> = minFor { columns.toComparableColumns() }
+
+public fun <T, C : Comparable<C>> Grouped<T>.minFor(vararg columns: ColumnReference<C?>): DataFrame<T> =
+    minFor { columns.toColumnSet() }
+
+public fun <T, C : Comparable<C>> Grouped<T>.minFor(vararg columns: KProperty<C?>): DataFrame<T> =
+    minFor { columns.toColumnSet() }
+
+public fun <T, C : Comparable<C>> Grouped<T>.min(name: String? = null, columns: ColumnsSelector<T, C?>): DataFrame<T> =
+    Aggregators.min.aggregateAll(this, name, columns)
+
+public fun <T> Grouped<T>.min(vararg columns: String, name: String? = null): DataFrame<T> =
+    min(name) { columns.toComparableColumns() }
+
+public fun <T, C : Comparable<C>> Grouped<T>.min(
+    vararg columns: ColumnReference<C?>,
+    name: String? = null,
+): DataFrame<T> = min(name) { columns.toColumnSet() }
+
+public fun <T, C : Comparable<C>> Grouped<T>.min(vararg columns: KProperty<C?>, name: String? = null): DataFrame<T> =
+    min(name) { columns.toColumnSet() }
+
+public fun <T, C : Comparable<C>> Grouped<T>.minOf(
+    name: String? = null,
+    expression: RowExpression<T, C>,
+): DataFrame<T> = Aggregators.min.aggregateOfDelegated(this, name) { minOfOrNull(expression) }
+
+public fun <T, G, R : Comparable<R>> GroupBy<T, G>.minBy(rowExpression: RowExpression<G, R?>): ReducedGroupBy<T, G> =
+    reduce { minByOrNull(rowExpression) }
+
+public fun <T, G, C : Comparable<C>> GroupBy<T, G>.minBy(column: ColumnReference<C?>): ReducedGroupBy<T, G> =
+    reduce { minByOrNull(column) }
+
+public fun <T, G> GroupBy<T, G>.minBy(column: String): ReducedGroupBy<T, G> =
+    minBy(column.toColumnAccessor().cast<Comparable<Any?>>())
+
+public fun <T, G, C : Comparable<C>> GroupBy<T, G>.minBy(column: KProperty<C?>): ReducedGroupBy<T, G> =
+    minBy(column.toColumnAccessor())
+
+// endregion
+
+// region Pivot
+
+public fun <T> Pivot<T>.min(separate: Boolean = false): DataRow<T> = delegate { min(separate) }
+
+public fun <T, R : Comparable<R>> Pivot<T>.minFor(
+    separate: Boolean = false,
+    columns: ColumnsForAggregateSelector<T, R?>,
+): DataRow<T> = delegate { minFor(separate, columns) }
+
+public fun <T> Pivot<T>.minFor(vararg columns: String, separate: Boolean = false): DataRow<T> =
+    minFor(separate) { columns.toComparableColumns() }
+
+public fun <T, R : Comparable<R>> Pivot<T>.minFor(
+    vararg columns: ColumnReference<R?>,
+    separate: Boolean = false,
+): DataRow<T> = minFor(separate) { columns.toColumnSet() }
+
+public fun <T, R : Comparable<R>> Pivot<T>.minFor(
+    vararg columns: KProperty<R?>,
+    separate: Boolean = false,
+): DataRow<T> = minFor(separate) { columns.toColumnSet() }
+
+public fun <T, R : Comparable<R>> Pivot<T>.min(columns: ColumnsSelector<T, R?>): DataRow<T> = delegate { min(columns) }
+
+public fun <T, R : Comparable<R>> Pivot<T>.min(vararg columns: String): DataRow<T> =
+    min { columns.toComparableColumns() }
+
+public fun <T, R : Comparable<R>> Pivot<T>.min(vararg columns: ColumnReference<R?>): DataRow<T> =
+    min { columns.toColumnSet() }
+
+public fun <T, R : Comparable<R>> Pivot<T>.min(vararg columns: KProperty<R?>): DataRow<T> =
+    min { columns.toColumnSet() }
+
+public fun <T, R : Comparable<R>> Pivot<T>.minOf(rowExpression: RowExpression<T, R>): DataRow<T> =
+    delegate { minOf(rowExpression) }
+
+public fun <T, R : Comparable<R>> Pivot<T>.minBy(rowExpression: RowExpression<T, R>): ReducedPivot<T> =
+    reduce { minByOrNull(rowExpression) }
+
+public fun <T, C : Comparable<C>> Pivot<T>.minBy(column: ColumnReference<C?>): ReducedPivot<T> =
+    reduce { minByOrNull(column) }
+
+public fun <T> Pivot<T>.minBy(column: String): ReducedPivot<T> =
+    minBy(column.toColumnAccessor().cast<Comparable<Any?>>())
+
+public fun <T, C : Comparable<C>> Pivot<T>.minBy(column: KProperty<C?>): ReducedPivot<T> =
+    minBy(column.toColumnAccessor())
+
+// endregion
+
+// region PivotGroupBy
+
+public fun <T> PivotGroupBy<T>.min(separate: Boolean = false): DataFrame<T> = minFor(separate, comparableColumns())
+
+public fun <T, R : Comparable<R>> PivotGroupBy<T>.minFor(
+    separate: Boolean = false,
+    columns: ColumnsForAggregateSelector<T, R?>,
+): DataFrame<T> = Aggregators.min.aggregateFor(this, separate, columns)
+
+public fun <T> PivotGroupBy<T>.minFor(vararg columns: String, separate: Boolean = false): DataFrame<T> =
+    minFor(separate) { columns.toComparableColumns() }
+
+public fun <T, R : Comparable<R>> PivotGroupBy<T>.minFor(
+    vararg columns: ColumnReference<R?>,
+    separate: Boolean = false,
+): DataFrame<T> = minFor(separate) { columns.toColumnSet() }
+
+public fun <T, R : Comparable<R>> PivotGroupBy<T>.minFor(
+    vararg columns: KProperty<R?>,
+    separate: Boolean = false,
+): DataFrame<T> = minFor(separate) { columns.toColumnSet() }
+
+public fun <T, R : Comparable<R>> PivotGroupBy<T>.min(columns: ColumnsSelector<T, R?>): DataFrame<T> =
+    Aggregators.min.aggregateAll(this, columns)
+
+public fun <T> PivotGroupBy<T>.min(vararg columns: String): DataFrame<T> = min { columns.toComparableColumns() }
+
+public fun <T, R : Comparable<R>> PivotGroupBy<T>.min(vararg columns: ColumnReference<R?>): DataFrame<T> =
+    min { columns.toColumnSet() }
+
+public fun <T, R : Comparable<R>> PivotGroupBy<T>.min(vararg columns: KProperty<R?>): DataFrame<T> =
+    min { columns.toColumnSet() }
+
+public fun <T, R : Comparable<R>> PivotGroupBy<T>.minOf(rowExpression: RowExpression<T, R>): DataFrame<T> =
+    aggregate { minOf(rowExpression) }
+
+public fun <T, R : Comparable<R>> PivotGroupBy<T>.minBy(rowExpression: RowExpression<T, R>): ReducedPivotGroupBy<T> =
+    reduce { minByOrNull(rowExpression) }
+
+public fun <T, C : Comparable<C>> PivotGroupBy<T>.minBy(column: ColumnReference<C?>): ReducedPivotGroupBy<T> =
+    reduce { minByOrNull(column) }
+
+public fun <T> PivotGroupBy<T>.minBy(column: String): ReducedPivotGroupBy<T> =
+    minBy(column.toColumnAccessor().cast<Comparable<Any?>>())
+
+public fun <T, C : Comparable<C>> PivotGroupBy<T>.minBy(column: KProperty<C?>): ReducedPivotGroupBy<T> =
+    minBy(column.toColumnAccessor())
+
+// endregion
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/move.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/move.kt
new file mode 100644
index 000000000..6fd3f3b59
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/move.kt
@@ -0,0 +1,162 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import org.jetbrains.kotlinx.dataframe.AnyColumnGroupAccessor
+import org.jetbrains.kotlinx.dataframe.AnyColumnReference
+import org.jetbrains.kotlinx.dataframe.ColumnSelector
+import org.jetbrains.kotlinx.dataframe.ColumnsSelector
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.annotations.Interpretable
+import org.jetbrains.kotlinx.dataframe.annotations.Refine
+import org.jetbrains.kotlinx.dataframe.columns.ColumnReference
+import org.jetbrains.kotlinx.dataframe.columns.ColumnWithPath
+import org.jetbrains.kotlinx.dataframe.columns.toColumnSet
+import org.jetbrains.kotlinx.dataframe.impl.api.afterOrBefore
+import org.jetbrains.kotlinx.dataframe.impl.api.moveImpl
+import org.jetbrains.kotlinx.dataframe.impl.api.moveTo
+import org.jetbrains.kotlinx.dataframe.ncol
+import kotlin.reflect.KProperty
+
+// region DataFrame
+
+// region move
+
+@Interpretable("Move0")
+public fun <T, C> DataFrame<T>.move(columns: ColumnsSelector<T, C>): MoveClause<T, C> = MoveClause(this, columns)
+
+public fun <T> DataFrame<T>.move(vararg cols: String): MoveClause<T, Any?> = move { cols.toColumnSet() }
+
+public fun <T, C> DataFrame<T>.move(vararg cols: ColumnReference<C>): MoveClause<T, C> = move { cols.toColumnSet() }
+
+public fun <T, C> DataFrame<T>.move(vararg cols: KProperty<C>): MoveClause<T, C> = move { cols.toColumnSet() }
+
+// endregion
+
+// region moveTo
+
+public fun <T> DataFrame<T>.moveTo(newColumnIndex: Int, columns: ColumnsSelector<T, *>): DataFrame<T> =
+    move(columns).to(newColumnIndex)
+
+public fun <T> DataFrame<T>.moveTo(newColumnIndex: Int, vararg columns: String): DataFrame<T> =
+    moveTo(newColumnIndex) { columns.toColumnSet() }
+
+public fun <T> DataFrame<T>.moveTo(newColumnIndex: Int, vararg columns: AnyColumnReference): DataFrame<T> =
+    moveTo(newColumnIndex) { columns.toColumnSet() }
+
+public fun <T> DataFrame<T>.moveTo(newColumnIndex: Int, vararg columns: KProperty<*>): DataFrame<T> =
+    moveTo(newColumnIndex) { columns.toColumnSet() }
+
+// endregion
+
+// region moveToLeft
+
+public fun <T> DataFrame<T>.moveToLeft(columns: ColumnsSelector<T, *>): DataFrame<T> = move(columns).toLeft()
+
+public fun <T> DataFrame<T>.moveToLeft(vararg columns: String): DataFrame<T> = moveToLeft { columns.toColumnSet() }
+
+public fun <T> DataFrame<T>.moveToLeft(vararg columns: AnyColumnReference): DataFrame<T> =
+    moveToLeft { columns.toColumnSet() }
+
+public fun <T> DataFrame<T>.moveToLeft(vararg columns: KProperty<*>): DataFrame<T> =
+    moveToLeft { columns.toColumnSet() }
+
+// endregion
+
+// region moveToRight
+
+public fun <T> DataFrame<T>.moveToRight(columns: ColumnsSelector<T, *>): DataFrame<T> = move(columns).toRight()
+
+public fun <T> DataFrame<T>.moveToRight(vararg columns: String): DataFrame<T> = moveToRight { columns.toColumnSet() }
+
+public fun <T> DataFrame<T>.moveToRight(vararg columns: AnyColumnReference): DataFrame<T> =
+    moveToRight { columns.toColumnSet() }
+
+public fun <T> DataFrame<T>.moveToRight(vararg columns: KProperty<*>): DataFrame<T> =
+    moveToRight { columns.toColumnSet() }
+
+// endregion
+
+// endregion
+
+// region MoveClause
+
+// region into
+
+public fun <T, C> MoveClause<T, C>.into(
+    column: ColumnsSelectionDsl<T>.(ColumnWithPath<C>) -> AnyColumnReference,
+): DataFrame<T> =
+    moveImpl(
+        under = false,
+        newPathExpression = column,
+    )
+
+public fun <T, C> MoveClause<T, C>.into(column: String): DataFrame<T> = pathOf(column).let { path -> into { path } }
+
+public fun <T, C> MoveClause<T, C>.intoIndexed(
+    newPathExpression: ColumnsSelectionDsl<T>.(ColumnWithPath<C>, Int) -> AnyColumnReference,
+): DataFrame<T> {
+    var counter = 0
+    return into { col ->
+        newPathExpression(this, col, counter++)
+    }
+}
+
+// endregion
+
+// region under
+
+public fun <T, C> MoveClause<T, C>.under(column: String): DataFrame<T> = pathOf(column).let { path -> under { path } }
+
+public fun <T, C> MoveClause<T, C>.under(column: AnyColumnGroupAccessor): DataFrame<T> =
+    column.path().let { path -> under { path } }
+
+public fun <T, C> MoveClause<T, C>.under(
+    column: ColumnsSelectionDsl<T>.(ColumnWithPath<C>) -> AnyColumnReference,
+): DataFrame<T> =
+    moveImpl(
+        under = true,
+        newPathExpression = column,
+    )
+
+// endregion
+
+// region to
+
+public fun <T, C> MoveClause<T, C>.to(columnIndex: Int): DataFrame<T> = moveTo(columnIndex)
+
+@Refine
+@Interpretable("ToTop")
+public fun <T, C> MoveClause<T, C>.toTop(
+    newColumnName: ColumnsSelectionDsl<T>.(ColumnWithPath<C>) -> String = { it.name() },
+): DataFrame<T> = into { newColumnName(it).toColumnAccessor() }
+
+// endregion
+
+// region after
+
+public fun <T, C> MoveClause<T, C>.after(column: ColumnSelector<T, *>): DataFrame<T> = afterOrBefore(column, true)
+
+public fun <T, C> MoveClause<T, C>.after(column: String): DataFrame<T> = after { column.toColumnAccessor() }
+
+public fun <T, C> MoveClause<T, C>.after(column: AnyColumnReference): DataFrame<T> = after { column }
+
+public fun <T, C> MoveClause<T, C>.after(column: KProperty<*>): DataFrame<T> = after { column.toColumnAccessor() }
+
+// endregion
+
+/* TODO: implement 'before'
+fun <T, C> MoveColsClause<T, C>.before(columnPath: ColumnPath) = before { columnPath.toColumnDef() }
+fun <T, C> MoveColsClause<T, C>.before(column: Column) = before { column }
+fun <T, C> MoveColsClause<T, C>.before(column: KProperty<*>) = before { column.toColumnDef() }
+fun <T, C> MoveColsClause<T, C>.before(column: String) = before { column.toColumnDef() }
+fun <T, C> MoveColsClause<T, C>.before(column: ColumnSelector<T, *>) = afterOrBefore(column, false)
+*/
+
+public fun <T, C> MoveClause<T, C>.toLeft(): DataFrame<T> = to(0)
+
+public fun <T, C> MoveClause<T, C>.toRight(): DataFrame<T> = to(df.ncol)
+
+public class MoveClause<T, C>(internal val df: DataFrame<T>, internal val columns: ColumnsSelector<T, C>) {
+    override fun toString(): String = "MoveClause(df=$df, columns=$columns)"
+}
+
+// endregion
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/none.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/none.kt
new file mode 100644
index 000000000..dc1fe8a99
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/none.kt
@@ -0,0 +1,77 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.columns.ColumnSet
+import org.jetbrains.kotlinx.dataframe.columns.ColumnsResolver
+import org.jetbrains.kotlinx.dataframe.impl.columns.ColumnsList
+
+// region ColumnsSelectionDsl
+
+/**
+ * ## None [Columns Selection DSL][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl]
+ *
+ * See [Grammar] for all functions in this interface.
+ */
+public interface NoneColumnsSelectionDsl {
+
+    /**
+     * ## None Grammar
+     *
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * [(What is this notation?)][org.jetbrains.kotlinx.dataframe.documentation.DslGrammar]
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  ### Definitions:
+     *
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  ### What can be called directly in the [Columns Selection DSL][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl]:
+     *
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  [**`none`**][org.jetbrains.kotlinx.dataframe.api.NoneColumnsSelectionDsl.none]**`()`**
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     */
+    public interface Grammar {
+
+        /** [**`none`**][ColumnsSelectionDsl.none] */
+        public interface PlainDslName
+    }
+
+    /**
+     * ## None
+     *
+     * Creates an empty [ColumnsResolver] / [ColumnSet], essentially selecting no columns at all.
+     *
+     * This is the opposite of [all][ColumnsSelectionDsl.all].
+     *
+     * ### Check out: [Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[groupBy][DataFrame.groupBy]`  {  `[`none`][none]`() }`
+     *
+     * @return An empty [ColumnsResolver].
+     */
+    public fun none(): ColumnsResolver<*> = ColumnsList<Any?>(emptyList())
+}
+
+// endregion
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/pivot.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/pivot.kt
new file mode 100644
index 000000000..16b67b84b
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/pivot.kt
@@ -0,0 +1,244 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import org.jetbrains.kotlinx.dataframe.AnyColumnReference
+import org.jetbrains.kotlinx.dataframe.ColumnsSelector
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.DataRow
+import org.jetbrains.kotlinx.dataframe.Selector
+import org.jetbrains.kotlinx.dataframe.aggregation.Aggregatable
+import org.jetbrains.kotlinx.dataframe.aggregation.AggregateBody
+import org.jetbrains.kotlinx.dataframe.aggregation.AggregateGroupedDsl
+import org.jetbrains.kotlinx.dataframe.columns.ColumnSet
+import org.jetbrains.kotlinx.dataframe.columns.ColumnsResolver
+import org.jetbrains.kotlinx.dataframe.columns.toColumnSet
+import org.jetbrains.kotlinx.dataframe.impl.aggregation.PivotGroupByImpl
+import org.jetbrains.kotlinx.dataframe.impl.aggregation.PivotImpl
+import org.jetbrains.kotlinx.dataframe.impl.aggregation.PivotInAggregateImpl
+import org.jetbrains.kotlinx.dataframe.impl.api.PivotChainColumnSet
+import kotlin.reflect.KProperty
+
+public interface PivotDsl<out T> : ColumnsSelectionDsl<T> {
+
+    public infix fun <C> ColumnsResolver<C>.then(other: ColumnsResolver<C>): ColumnSet<C> =
+        PivotChainColumnSet(this, other)
+
+    public infix fun <C> String.then(other: ColumnsResolver<C>): ColumnSet<C> = toColumnOf<C>() then other
+
+    public infix fun <C> ColumnsResolver<C>.then(other: String): ColumnSet<C> = this then other.toColumnOf()
+
+    public infix fun String.then(other: String): ColumnSet<Any?> = toColumnAccessor() then other.toColumnAccessor()
+
+    public infix fun <C> KProperty<C>.then(other: ColumnsResolver<C>): ColumnSet<C> = toColumnAccessor() then other
+
+    public infix fun <C> ColumnsResolver<C>.then(other: KProperty<C>): ColumnSet<C> = this then other.toColumnAccessor()
+
+    public infix fun <C> KProperty<C>.then(other: KProperty<C>): ColumnSet<C> =
+        toColumnAccessor() then other.toColumnAccessor()
+
+    public infix fun <C> KProperty<C>.then(other: String): ColumnSet<C> = toColumnAccessor() then other.toColumnOf()
+
+    public infix fun <C> String.then(other: KProperty<C>): ColumnSet<C> = toColumnOf<C>() then other.toColumnAccessor()
+}
+
+// region DataFrame
+
+// region pivot
+
+public fun <T> DataFrame<T>.pivot(inward: Boolean? = null, columns: PivotColumnsSelector<T, *>): Pivot<T> =
+    PivotImpl(this, columns, inward)
+
+public fun <T> DataFrame<T>.pivot(vararg columns: String, inward: Boolean? = null): Pivot<T> =
+    pivot(inward) { columns.toColumnSet() }
+
+public fun <T> DataFrame<T>.pivot(vararg columns: AnyColumnReference, inward: Boolean? = null): Pivot<T> =
+    pivot(inward) { columns.toColumnSet() }
+
+public fun <T> DataFrame<T>.pivot(vararg columns: KProperty<*>, inward: Boolean? = null): Pivot<T> =
+    pivot(inward) { columns.toColumnSet() }
+
+// endregion
+
+// region pivotMatches
+
+public fun <T> DataFrame<T>.pivotMatches(inward: Boolean = true, columns: ColumnsSelector<T, *>): DataFrame<T> =
+    pivot(inward, columns).groupByOther().matches()
+
+public fun <T> DataFrame<T>.pivotMatches(vararg columns: String, inward: Boolean = true): DataFrame<T> =
+    pivotMatches(inward) { columns.toColumnSet() }
+
+public fun <T> DataFrame<T>.pivotMatches(vararg columns: AnyColumnReference, inward: Boolean = true): DataFrame<T> =
+    pivotMatches(inward) { columns.toColumnSet() }
+
+public fun <T> DataFrame<T>.pivotMatches(vararg columns: KProperty<*>, inward: Boolean = true): DataFrame<T> =
+    pivotMatches(inward) { columns.toColumnSet() }
+
+// endregion
+
+// region pivotCounts
+
+public fun <T> DataFrame<T>.pivotCounts(inward: Boolean = true, columns: ColumnsSelector<T, *>): DataFrame<T> =
+    pivot(inward, columns).groupByOther().count()
+
+public fun <T> DataFrame<T>.pivotCounts(vararg columns: String, inward: Boolean = true): DataFrame<T> =
+    pivotCounts(inward) { columns.toColumnSet() }
+
+public fun <T> DataFrame<T>.pivotCounts(vararg columns: AnyColumnReference, inward: Boolean = true): DataFrame<T> =
+    pivotCounts(inward) { columns.toColumnSet() }
+
+public fun <T> DataFrame<T>.pivotCounts(vararg columns: KProperty<*>, inward: Boolean = true): DataFrame<T> =
+    pivotCounts(inward) { columns.toColumnSet() }
+
+// endregion
+
+// endregion
+
+// region GroupBy
+
+// region pivot
+
+public fun <G> GroupBy<*, G>.pivot(inward: Boolean = true, columns: ColumnsSelector<G, *>): PivotGroupBy<G> =
+    PivotGroupByImpl(this, columns, inward)
+
+public fun <G> GroupBy<*, G>.pivot(vararg columns: AnyColumnReference, inward: Boolean = true): PivotGroupBy<G> =
+    pivot(inward) { columns.toColumnSet() }
+
+public fun <G> GroupBy<*, G>.pivot(vararg columns: String, inward: Boolean = true): PivotGroupBy<G> =
+    pivot(inward) { columns.toColumnSet() }
+
+public fun <G> GroupBy<*, G>.pivot(vararg columns: KProperty<*>, inward: Boolean = true): PivotGroupBy<G> =
+    pivot(inward) { columns.toColumnSet() }
+
+// endregion
+
+// region pivotMatches
+
+public fun <G> GroupBy<*, G>.pivotMatches(inward: Boolean = true, columns: ColumnsSelector<G, *>): DataFrame<G> =
+    pivot(inward, columns).matches()
+
+public fun <G> GroupBy<*, G>.pivotMatches(vararg columns: String, inward: Boolean = true): DataFrame<G> =
+    pivotMatches(inward) { columns.toColumnSet() }
+
+public fun <G> GroupBy<*, G>.pivotMatches(vararg columns: AnyColumnReference, inward: Boolean = true): DataFrame<G> =
+    pivotMatches(inward) { columns.toColumnSet() }
+
+public fun <G> GroupBy<*, G>.pivotMatches(vararg columns: KProperty<*>, inward: Boolean = true): DataFrame<G> =
+    pivotMatches(inward) { columns.toColumnSet() }
+
+// endregion
+
+// region pivotCounts
+
+public fun <G> GroupBy<*, G>.pivotCounts(inward: Boolean = true, columns: ColumnsSelector<G, *>): DataFrame<G> =
+    pivot(inward, columns).count()
+
+public fun <G> GroupBy<*, G>.pivotCounts(vararg columns: String, inward: Boolean = true): DataFrame<G> =
+    pivotCounts(inward) { columns.toColumnSet() }
+
+public fun <G> GroupBy<*, G>.pivotCounts(vararg columns: AnyColumnReference, inward: Boolean = true): DataFrame<G> =
+    pivotCounts(inward) { columns.toColumnSet() }
+
+public fun <G> GroupBy<*, G>.pivotCounts(vararg columns: KProperty<*>, inward: Boolean = true): DataFrame<G> =
+    pivotCounts(inward) { columns.toColumnSet() }
+
+// endregion
+
+// endregion
+
+// region GroupBy.aggregate
+
+// region pivot
+
+public fun <T> AggregateGroupedDsl<T>.pivot(
+    inward: Boolean = true,
+    columns: PivotColumnsSelector<T, *>,
+): PivotGroupBy<T> = PivotInAggregateImpl(this, columns, inward)
+
+public fun <T> AggregateGroupedDsl<T>.pivot(vararg columns: String, inward: Boolean = true): PivotGroupBy<T> =
+    pivot(inward) { columns.toColumnSet() }
+
+public fun <T> AggregateGroupedDsl<T>.pivot(
+    vararg columns: AnyColumnReference,
+    inward: Boolean = true,
+): PivotGroupBy<T> = pivot(inward) { columns.toColumnSet() }
+
+public fun <T> AggregateGroupedDsl<T>.pivot(vararg columns: KProperty<*>, inward: Boolean = true): PivotGroupBy<T> =
+    pivot(inward) { columns.toColumnSet() }
+
+// endregion
+
+// region pivotMatches
+
+public fun <T> AggregateGroupedDsl<T>.pivotMatches(
+    inward: Boolean = true,
+    columns: ColumnsSelector<T, *>,
+): DataFrame<T> = pivot(inward, columns).matches()
+
+public fun <T> AggregateGroupedDsl<T>.pivotMatches(vararg columns: String, inward: Boolean = true): DataFrame<T> =
+    pivotMatches(inward) { columns.toColumnSet() }
+
+public fun <T> AggregateGroupedDsl<T>.pivotMatches(
+    vararg columns: AnyColumnReference,
+    inward: Boolean = true,
+): DataFrame<T> = pivotMatches(inward) { columns.toColumnSet() }
+
+public fun <T> AggregateGroupedDsl<T>.pivotMatches(vararg columns: KProperty<*>, inward: Boolean = true): DataFrame<T> =
+    pivotMatches(inward) { columns.toColumnSet() }
+
+// endregion
+
+// region pivotCounts
+
+public fun <T> AggregateGroupedDsl<T>.pivotCounts(
+    inward: Boolean = true,
+    columns: ColumnsSelector<T, *>,
+): DataFrame<T> = pivot(inward, columns).matches()
+
+public fun <T> AggregateGroupedDsl<T>.pivotCounts(vararg columns: String, inward: Boolean = true): DataFrame<T> =
+    pivotCounts(inward) { columns.toColumnSet() }
+
+public fun <T> AggregateGroupedDsl<T>.pivotCounts(
+    vararg columns: AnyColumnReference,
+    inward: Boolean = true,
+): DataFrame<T> = pivotCounts(inward) { columns.toColumnSet() }
+
+public fun <T> AggregateGroupedDsl<T>.pivotCounts(vararg columns: KProperty<*>, inward: Boolean = true): DataFrame<T> =
+    pivotCounts(inward) { columns.toColumnSet() }
+
+// endregion
+
+// endregion
+
+public interface Pivot<T> : Aggregatable<T>
+
+public typealias PivotColumnsSelector<T, C> = Selector<PivotDsl<T>, ColumnsResolver<C>>
+
+public class ReducedPivot<T>(
+    @PublishedApi internal val pivot: Pivot<T>,
+    @PublishedApi internal val reducer: Selector<DataFrame<T>, DataRow<T>?>,
+) {
+    override fun toString(): String = "ReducedPivot(pivot=$pivot, reducer=$reducer)"
+}
+
+internal fun <T> Pivot<T>.reduce(reducer: Selector<DataFrame<T>, DataRow<T>?>) = ReducedPivot(this, reducer)
+
+@PublishedApi
+internal inline fun <T> Pivot<T>.delegate(crossinline body: PivotGroupBy<T>.() -> DataFrame<T>): DataRow<T> =
+    body(groupBy { none() })[0]
+
+public interface PivotGroupBy<out T> : Aggregatable<T> {
+
+    public fun <R> aggregate(separate: Boolean = false, body: AggregateBody<T, R>): DataFrame<T>
+
+    public fun default(value: Any?): PivotGroupBy<T>
+}
+
+public class ReducedPivotGroupBy<T>(
+    @PublishedApi internal val pivot: PivotGroupBy<T>,
+    @PublishedApi internal val reducer: Selector<DataFrame<T>, DataRow<T>?>,
+) {
+    override fun toString(): String = "ReducedPivotGroupBy(pivot=$pivot, reducer=$reducer)"
+}
+
+@PublishedApi
+internal fun <T> PivotGroupBy<T>.reduce(reducer: Selector<DataFrame<T>, DataRow<T>?>): ReducedPivotGroupBy<T> =
+    ReducedPivotGroupBy(this, reducer)
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/print.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/print.kt
new file mode 100644
index 000000000..b515b7ba1
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/print.kt
@@ -0,0 +1,46 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import org.jetbrains.kotlinx.dataframe.DataColumn
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.DataRow
+import org.jetbrains.kotlinx.dataframe.io.renderToString
+import org.jetbrains.kotlinx.dataframe.schema.DataFrameSchema
+
+// region DataColumn
+
+public fun <T> DataColumn<T>.print(): Unit = println(this)
+
+// endregion
+
+// region DataRow
+
+public fun <T> DataRow<T>.print(): Unit = println(this)
+
+// endregion
+
+// region DataFrame
+
+public fun <T> DataFrame<T>.print(
+    rowsLimit: Int = 20,
+    valueLimit: Int = 40,
+    borders: Boolean = false,
+    alignLeft: Boolean = false,
+    columnTypes: Boolean = false,
+    title: Boolean = false,
+): Unit = println(renderToString(rowsLimit, valueLimit, borders, alignLeft, columnTypes, title))
+
+// endregion
+
+// region GroupBy
+
+public fun <T, G> GroupBy<T, G>.print(): Unit = println(this)
+
+// endregion
+
+// region DataFrameSchema
+
+public fun DataFrameSchema.print(): Unit = println(this)
+
+// endregion
+
+public fun CodeString.print(): Unit = println(this)
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/remove.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/remove.kt
new file mode 100644
index 000000000..39ef71fa4
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/remove.kt
@@ -0,0 +1,41 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import org.jetbrains.kotlinx.dataframe.AnyColumnReference
+import org.jetbrains.kotlinx.dataframe.ColumnsSelector
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.annotations.Interpretable
+import org.jetbrains.kotlinx.dataframe.annotations.Refine
+import org.jetbrains.kotlinx.dataframe.columns.toColumnSet
+import org.jetbrains.kotlinx.dataframe.impl.api.removeImpl
+import kotlin.reflect.KProperty
+
+// region DataFrame
+
+// region remove
+
+@Refine
+@Interpretable("Remove0")
+public fun <T> DataFrame<T>.remove(columns: ColumnsSelector<T, *>): DataFrame<T> =
+    removeImpl(allowMissingColumns = true, columns = columns).df
+
+public fun <T> DataFrame<T>.remove(vararg columns: String): DataFrame<T> = remove { columns.toColumnSet() }
+
+public fun <T> DataFrame<T>.remove(vararg columns: AnyColumnReference): DataFrame<T> = remove { columns.toColumnSet() }
+
+public fun <T> DataFrame<T>.remove(vararg columns: KProperty<*>): DataFrame<T> = remove { columns.toColumnSet() }
+
+// endregion
+
+// region minus
+
+public infix operator fun <T> DataFrame<T>.minus(columns: ColumnsSelector<T, *>): DataFrame<T> = remove(columns)
+
+public infix operator fun <T> DataFrame<T>.minus(column: String): DataFrame<T> = remove(column)
+
+public infix operator fun <T> DataFrame<T>.minus(column: AnyColumnReference): DataFrame<T> = remove(column)
+
+public infix operator fun <T> DataFrame<T>.minus(columns: KProperty<*>): DataFrame<T> = remove(columns)
+
+// endregion
+
+// endregion
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/rename.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/rename.kt
new file mode 100644
index 000000000..851a0d4d0
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/rename.kt
@@ -0,0 +1,743 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import org.jetbrains.kotlinx.dataframe.AnyFrame
+import org.jetbrains.kotlinx.dataframe.ColumnsSelector
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.annotations.HasSchema
+import org.jetbrains.kotlinx.dataframe.annotations.Interpretable
+import org.jetbrains.kotlinx.dataframe.annotations.Refine
+import org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor
+import org.jetbrains.kotlinx.dataframe.columns.ColumnReference
+import org.jetbrains.kotlinx.dataframe.columns.ColumnWithPath
+import org.jetbrains.kotlinx.dataframe.columns.FrameColumn
+import org.jetbrains.kotlinx.dataframe.columns.renamedReference
+import org.jetbrains.kotlinx.dataframe.columns.toColumnSet
+import org.jetbrains.kotlinx.dataframe.impl.DELIMITED_STRING_REGEX
+import org.jetbrains.kotlinx.dataframe.impl.DELIMITERS_REGEX
+import org.jetbrains.kotlinx.dataframe.impl.api.renameImpl
+import org.jetbrains.kotlinx.dataframe.impl.columnName
+import org.jetbrains.kotlinx.dataframe.impl.toCamelCaseByDelimiters
+import kotlin.reflect.KProperty
+
+// region DataFrame
+
+public fun <T> DataFrame<T>.rename(vararg mappings: Pair<String, String>): DataFrame<T> =
+    rename { mappings.map { it.first.toColumnAccessor() }.toColumnSet() }
+        .into(*mappings.map { it.second }.toTypedArray())
+
+@Interpretable("Rename")
+public fun <T, C> DataFrame<T>.rename(columns: ColumnsSelector<T, C>): RenameClause<T, C> = RenameClause(this, columns)
+
+public fun <T, C> DataFrame<T>.rename(vararg cols: ColumnReference<C>): RenameClause<T, C> =
+    rename { cols.toColumnSet() }
+
+public fun <T, C> DataFrame<T>.rename(vararg cols: KProperty<C>): RenameClause<T, C> = rename { cols.toColumnSet() }
+
+public fun <T> DataFrame<T>.rename(vararg cols: String): RenameClause<T, Any?> = rename { cols.toColumnSet() }
+
+@HasSchema(schemaArg = 0)
+public class RenameClause<T, C>(internal val df: DataFrame<T>, internal val columns: ColumnsSelector<T, C>) {
+    override fun toString(): String = "RenameClause(df=$df, columns=$columns)"
+}
+
+/**
+ * ## Rename to camelCase
+ *
+ * This function renames all columns to `camelCase` by replacing all [delimiters][DELIMITERS_REGEX]
+ * and converting the first char to lowercase.
+ * Even [DataFrames][DataFrame] inside [FrameColumns][FrameColumn] are traversed recursively.
+ */
+public fun <T> DataFrame<T>.renameToCamelCase(): DataFrame<T> =
+    // recursively rename all columns written with delimiters or starting with a capital to camel case
+    rename {
+        colsAtAnyDepth { it.name() matches DELIMITED_STRING_REGEX || it.name[0].isUpperCase() }
+    }.toCamelCase()
+        // take all frame columns at any depth and call renameToCamelCase() on all dataframes inside
+        .update {
+            colsAtAnyDepth().colsOf<AnyFrame>()
+        }.with { it.renameToCamelCase() }
+
+public fun <T, C> RenameClause<T, C>.into(vararg newColumns: ColumnReference<*>): DataFrame<T> =
+    into(*newColumns.map { it.name() }.toTypedArray())
+
+@Refine
+@Interpretable("RenameInto")
+public fun <T, C> RenameClause<T, C>.into(vararg newNames: String): DataFrame<T> = renameImpl(newNames)
+
+public fun <T, C> RenameClause<T, C>.into(vararg newNames: KProperty<*>): DataFrame<T> =
+    into(*newNames.map { it.name }.toTypedArray())
+
+public fun <T, C> RenameClause<T, C>.into(transform: (ColumnWithPath<C>) -> String): DataFrame<T> =
+    renameImpl(transform)
+
+/**
+ * ## Rename to camelCase
+ *
+ * Renames the selected columns to `camelCase` by replacing all [delimiters][DELIMITERS_REGEX]
+ * and converting the first char to lowercase.
+ */
+public fun <T, C> RenameClause<T, C>.toCamelCase(): DataFrame<T> =
+    into {
+        it.name()
+            .toCamelCaseByDelimiters(DELIMITERS_REGEX)
+            .replaceFirstChar { it.lowercaseChar() }
+    }
+
+// endregion
+
+// region DataColumn
+
+@Suppress("UNCHECKED_CAST")
+public fun <T, C : ColumnReference<T>> C.rename(column: KProperty<T>): C = rename(column.columnName) as C
+
+@Suppress("UNCHECKED_CAST")
+public fun <T, C : ColumnReference<T>> C.rename(column: ColumnAccessor<T>): C = rename(column.name()) as C
+
+// endregion
+
+// region named
+
+@Suppress("UNCHECKED_CAST")
+public infix fun <T, C : ColumnReference<T>> C.named(name: String): C = rename(name) as C
+
+public infix fun <T, C : ColumnReference<T>> C.named(name: KProperty<*>): C = rename(name)
+
+public infix fun <T, C : ColumnReference<T>> C.named(name: ColumnAccessor<*>): C = rename(name)
+
+// endregion
+
+// region ColumnsSelectionDsl
+
+/**
+ * ## Rename: `named` / `into` [Columns Selection DSL][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl]
+ *
+ * See [Grammar] for all functions in this interface.
+ */
+public interface RenameColumnsSelectionDsl {
+
+    /**
+     * ## Rename: `named` / `into` Grammar
+     *
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * [(What is this notation?)][org.jetbrains.kotlinx.dataframe.documentation.DslGrammar]
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  ### Definitions:
+     *  `column: `[`ColumnAccessor`][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor]`  |  `[`String`][String]`  | `[`KProperty`][kotlin.reflect.KProperty]`<*> | `[`ColumnPath`][org.jetbrains.kotlinx.dataframe.columns.ColumnPath]
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  ### What can be called directly in the [Columns Selection DSL][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl]:
+     *
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  [`column`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ColumnDef]` `[**named**][org.jetbrains.kotlinx.dataframe.api.RenameColumnsSelectionDsl.named]`/`[**into**][org.jetbrains.kotlinx.dataframe.api.RenameColumnsSelectionDsl.into]` `[`column`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ColumnDef]
+     *
+     *  `| `[`column`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ColumnDef]__`.`__[**named**][org.jetbrains.kotlinx.dataframe.api.RenameColumnsSelectionDsl.named]**`(`**[`column`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ColumnDef]**`)`**
+     *
+     *  `| `[`column`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ColumnDef]__`.`__[**into**][org.jetbrains.kotlinx.dataframe.api.RenameColumnsSelectionDsl.into]**`(`**[`column`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ColumnDef]**`)`**
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     */
+    public interface Grammar {
+
+        /** [**named**][ColumnsSelectionDsl.named] */
+        public interface InfixNamedName
+
+        /** [**into**][ColumnsSelectionDsl.into] */
+        public interface InfixIntoName
+
+        /** __`.`__[**named**][ColumnsSelectionDsl.named] */
+        public interface NamedName
+
+        /** __`.`__[**into**][ColumnsSelectionDsl.into] */
+        public interface IntoName
+    }
+
+    /**
+     * ## Rename: `named` / `into`
+     * Renaming a column in the [ColumnsSelectionDsl] is done by calling the `infix` functions
+     * [named][ColumnReference.named] or [into][ColumnReference.into]. They behave exactly the same,
+     * so it's up to contextual preference which one to use. Any combination of [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi] can be
+     * used to specify the column to rename and which name should be used instead.
+     *
+     * ### Check out: [Grammar]
+     *
+     * #### For Example:
+     *
+     * `df.`[select][DataFrame.select]`  { name  `[named][ColumnReference.named]` "Full Name" }`
+     *
+     * `df.`[select][DataFrame.select]`  {  `[expr][expr]`  { 0 }  `[into][ColumnReference.into]` "zeroes" }`
+     *
+     * `df.`[select][DataFrame.select]`  { "colA"  `[named][String.named]` Type::colB }`
+     *
+     * #### Example for this overload:
+     *
+     * `df.`[select][DataFrame.select]`  {   `[][.]`  }`
+     *
+     * @receiver The [] referencing the column to rename.
+     * @param [] A [] used to specify the new name of the column.
+     * @return A [ColumnReference] to the renamed column.
+     */
+    private interface CommonRenameDocs {
+
+        interface ReceiverArg
+
+        interface ReceiverTypeArg
+
+        /** "named" or "into" */
+        interface FunctionNameArg
+
+        /** "newName" or "nameOf" */
+        interface ParamNameArg
+
+        interface ParamArg
+
+        interface ParamTypeArg
+
+        /**
+         */
+        interface ColumnReferenceReceiver
+
+        /**
+         */
+        interface StringReceiver
+
+        /**
+         */
+        interface KPropertyReceiver
+
+        /**
+         */
+        interface ColumnReferenceParam
+
+        /**
+         */
+        interface StringParam
+
+        /**
+         */
+        interface KPropertyParam
+
+        interface NamedFunctionName
+
+        interface IntoFunctionName
+    }
+
+    // region named
+
+    /**
+     * ## Rename: `named` / `into`
+     * Renaming a column in the [ColumnsSelectionDsl][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl] is done by calling the `infix` functions
+     * [named][org.jetbrains.kotlinx.dataframe.columns.ColumnReference.named] or [into][org.jetbrains.kotlinx.dataframe.columns.ColumnReference.into]. They behave exactly the same,
+     * so it's up to contextual preference which one to use. Any combination of [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi] can be
+     * used to specify the column to rename and which name should be used instead.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.RenameColumnsSelectionDsl.Grammar]
+     *
+     * #### For Example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  { name  `[named][org.jetbrains.kotlinx.dataframe.columns.ColumnReference.named]` "Full Name" }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[expr][org.jetbrains.kotlinx.dataframe.api.expr]`  { 0 }  `[into][org.jetbrains.kotlinx.dataframe.columns.ColumnReference.into]` "zeroes" }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  { "colA"  `[named][kotlin.String.named]` Type::colB }`
+     *
+     * #### Example for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  { columnA  `[named][ColumnReference.named]` "columnB" }`
+     *
+     * @receiver The [ColumnReference] referencing the column to rename.
+     * @param [newName] A [String] used to specify the new name of the column.
+     * @return A [ColumnReference][org.jetbrains.kotlinx.dataframe.columns.ColumnReference] to the renamed column.
+     */
+    public infix fun <C> ColumnReference<C>.named(newName: String): ColumnReference<C> = renamedReference(newName)
+
+    /**
+     * ## Rename: `named` / `into`
+     * Renaming a column in the [ColumnsSelectionDsl][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl] is done by calling the `infix` functions
+     * [named][org.jetbrains.kotlinx.dataframe.columns.ColumnReference.named] or [into][org.jetbrains.kotlinx.dataframe.columns.ColumnReference.into]. They behave exactly the same,
+     * so it's up to contextual preference which one to use. Any combination of [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi] can be
+     * used to specify the column to rename and which name should be used instead.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.RenameColumnsSelectionDsl.Grammar]
+     *
+     * #### For Example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  { name  `[named][org.jetbrains.kotlinx.dataframe.columns.ColumnReference.named]` "Full Name" }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[expr][org.jetbrains.kotlinx.dataframe.api.expr]`  { 0 }  `[into][org.jetbrains.kotlinx.dataframe.columns.ColumnReference.into]` "zeroes" }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  { "colA"  `[named][kotlin.String.named]` Type::colB }`
+     *
+     * #### Example for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  { columnA  `[named][ColumnReference.named]` columnB }`
+     *
+     * @receiver The [ColumnReference] referencing the column to rename.
+     * @param [nameOf] A [ColumnReference] used to specify the new name of the column.
+     * @return A [ColumnReference][org.jetbrains.kotlinx.dataframe.columns.ColumnReference] to the renamed column.
+     */
+    public infix fun <C> ColumnReference<C>.named(nameOf: ColumnReference<*>): ColumnReference<C> = named(nameOf.name)
+
+    /**
+     * ## Rename: `named` / `into`
+     * Renaming a column in the [ColumnsSelectionDsl][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl] is done by calling the `infix` functions
+     * [named][org.jetbrains.kotlinx.dataframe.columns.ColumnReference.named] or [into][org.jetbrains.kotlinx.dataframe.columns.ColumnReference.into]. They behave exactly the same,
+     * so it's up to contextual preference which one to use. Any combination of [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi] can be
+     * used to specify the column to rename and which name should be used instead.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.RenameColumnsSelectionDsl.Grammar]
+     *
+     * #### For Example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  { name  `[named][org.jetbrains.kotlinx.dataframe.columns.ColumnReference.named]` "Full Name" }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[expr][org.jetbrains.kotlinx.dataframe.api.expr]`  { 0 }  `[into][org.jetbrains.kotlinx.dataframe.columns.ColumnReference.into]` "zeroes" }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  { "colA"  `[named][kotlin.String.named]` Type::colB }`
+     *
+     * #### Example for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  { columnA  `[named][ColumnReference.named]` Type::columnB }`
+     *
+     * @receiver The [ColumnReference] referencing the column to rename.
+     * @param [nameOf] A [KProperty] used to specify the new name of the column.
+     * @return A [ColumnReference][org.jetbrains.kotlinx.dataframe.columns.ColumnReference] to the renamed column.
+     */
+    public infix fun <C> ColumnReference<C>.named(nameOf: KProperty<*>): ColumnReference<C> = named(nameOf.columnName)
+
+    /**
+     * ## Rename: `named` / `into`
+     * Renaming a column in the [ColumnsSelectionDsl][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl] is done by calling the `infix` functions
+     * [named][org.jetbrains.kotlinx.dataframe.columns.ColumnReference.named] or [into][org.jetbrains.kotlinx.dataframe.columns.ColumnReference.into]. They behave exactly the same,
+     * so it's up to contextual preference which one to use. Any combination of [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi] can be
+     * used to specify the column to rename and which name should be used instead.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.RenameColumnsSelectionDsl.Grammar]
+     *
+     * #### For Example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  { name  `[named][org.jetbrains.kotlinx.dataframe.columns.ColumnReference.named]` "Full Name" }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[expr][org.jetbrains.kotlinx.dataframe.api.expr]`  { 0 }  `[into][org.jetbrains.kotlinx.dataframe.columns.ColumnReference.into]` "zeroes" }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  { "colA"  `[named][kotlin.String.named]` Type::colB }`
+     *
+     * #### Example for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  { "columnA"  `[named][String.named]` "columnB" }`
+     *
+     * @receiver The [String] referencing the column to rename.
+     * @param [newName] A [String] used to specify the new name of the column.
+     * @return A [ColumnReference][org.jetbrains.kotlinx.dataframe.columns.ColumnReference] to the renamed column.
+     */
+    public infix fun String.named(newName: String): ColumnReference<*> = toColumnAccessor().named(newName)
+
+    /**
+     * ## Rename: `named` / `into`
+     * Renaming a column in the [ColumnsSelectionDsl][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl] is done by calling the `infix` functions
+     * [named][org.jetbrains.kotlinx.dataframe.columns.ColumnReference.named] or [into][org.jetbrains.kotlinx.dataframe.columns.ColumnReference.into]. They behave exactly the same,
+     * so it's up to contextual preference which one to use. Any combination of [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi] can be
+     * used to specify the column to rename and which name should be used instead.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.RenameColumnsSelectionDsl.Grammar]
+     *
+     * #### For Example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  { name  `[named][org.jetbrains.kotlinx.dataframe.columns.ColumnReference.named]` "Full Name" }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[expr][org.jetbrains.kotlinx.dataframe.api.expr]`  { 0 }  `[into][org.jetbrains.kotlinx.dataframe.columns.ColumnReference.into]` "zeroes" }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  { "colA"  `[named][kotlin.String.named]` Type::colB }`
+     *
+     * #### Example for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  { "columnA"  `[named][String.named]` columnB }`
+     *
+     * @receiver The [String] referencing the column to rename.
+     * @param [nameOf] A [ColumnReference] used to specify the new name of the column.
+     * @return A [ColumnReference][org.jetbrains.kotlinx.dataframe.columns.ColumnReference] to the renamed column.
+     */
+    public infix fun String.named(nameOf: ColumnReference<*>): ColumnReference<*> =
+        toColumnAccessor().named(nameOf.name)
+
+    /**
+     * ## Rename: `named` / `into`
+     * Renaming a column in the [ColumnsSelectionDsl][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl] is done by calling the `infix` functions
+     * [named][org.jetbrains.kotlinx.dataframe.columns.ColumnReference.named] or [into][org.jetbrains.kotlinx.dataframe.columns.ColumnReference.into]. They behave exactly the same,
+     * so it's up to contextual preference which one to use. Any combination of [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi] can be
+     * used to specify the column to rename and which name should be used instead.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.RenameColumnsSelectionDsl.Grammar]
+     *
+     * #### For Example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  { name  `[named][org.jetbrains.kotlinx.dataframe.columns.ColumnReference.named]` "Full Name" }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[expr][org.jetbrains.kotlinx.dataframe.api.expr]`  { 0 }  `[into][org.jetbrains.kotlinx.dataframe.columns.ColumnReference.into]` "zeroes" }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  { "colA"  `[named][kotlin.String.named]` Type::colB }`
+     *
+     * #### Example for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  { "columnA"  `[named][String.named]` Type::columnB }`
+     *
+     * @receiver The [String] referencing the column to rename.
+     * @param [nameOf] A [KProperty] used to specify the new name of the column.
+     * @return A [ColumnReference][org.jetbrains.kotlinx.dataframe.columns.ColumnReference] to the renamed column.
+     */
+    public infix fun String.named(nameOf: KProperty<*>): ColumnReference<*> =
+        toColumnAccessor().named(nameOf.columnName)
+
+    /**
+     * ## Rename: `named` / `into`
+     * Renaming a column in the [ColumnsSelectionDsl][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl] is done by calling the `infix` functions
+     * [named][org.jetbrains.kotlinx.dataframe.columns.ColumnReference.named] or [into][org.jetbrains.kotlinx.dataframe.columns.ColumnReference.into]. They behave exactly the same,
+     * so it's up to contextual preference which one to use. Any combination of [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi] can be
+     * used to specify the column to rename and which name should be used instead.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.RenameColumnsSelectionDsl.Grammar]
+     *
+     * #### For Example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  { name  `[named][org.jetbrains.kotlinx.dataframe.columns.ColumnReference.named]` "Full Name" }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[expr][org.jetbrains.kotlinx.dataframe.api.expr]`  { 0 }  `[into][org.jetbrains.kotlinx.dataframe.columns.ColumnReference.into]` "zeroes" }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  { "colA"  `[named][kotlin.String.named]` Type::colB }`
+     *
+     * #### Example for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  { Type::columnA  `[named][KProperty.named]` "columnB" }`
+     *
+     * @receiver The [KProperty] referencing the column to rename.
+     * @param [newName] A [String] used to specify the new name of the column.
+     * @return A [ColumnReference][org.jetbrains.kotlinx.dataframe.columns.ColumnReference] to the renamed column.
+     */
+    public infix fun <C> KProperty<C>.named(newName: String): ColumnReference<C> = toColumnAccessor().named(newName)
+
+    /**
+     * ## Rename: `named` / `into`
+     * Renaming a column in the [ColumnsSelectionDsl][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl] is done by calling the `infix` functions
+     * [named][org.jetbrains.kotlinx.dataframe.columns.ColumnReference.named] or [into][org.jetbrains.kotlinx.dataframe.columns.ColumnReference.into]. They behave exactly the same,
+     * so it's up to contextual preference which one to use. Any combination of [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi] can be
+     * used to specify the column to rename and which name should be used instead.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.RenameColumnsSelectionDsl.Grammar]
+     *
+     * #### For Example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  { name  `[named][org.jetbrains.kotlinx.dataframe.columns.ColumnReference.named]` "Full Name" }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[expr][org.jetbrains.kotlinx.dataframe.api.expr]`  { 0 }  `[into][org.jetbrains.kotlinx.dataframe.columns.ColumnReference.into]` "zeroes" }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  { "colA"  `[named][kotlin.String.named]` Type::colB }`
+     *
+     * #### Example for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  { Type::columnA  `[named][KProperty.named]` columnB }`
+     *
+     * @receiver The [KProperty] referencing the column to rename.
+     * @param [nameOf] A [ColumnReference] used to specify the new name of the column.
+     * @return A [ColumnReference][org.jetbrains.kotlinx.dataframe.columns.ColumnReference] to the renamed column.
+     */
+    public infix fun <C> KProperty<C>.named(nameOf: ColumnReference<*>): ColumnReference<C> =
+        toColumnAccessor().named(nameOf.name)
+
+    /**
+     * ## Rename: `named` / `into`
+     * Renaming a column in the [ColumnsSelectionDsl][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl] is done by calling the `infix` functions
+     * [named][org.jetbrains.kotlinx.dataframe.columns.ColumnReference.named] or [into][org.jetbrains.kotlinx.dataframe.columns.ColumnReference.into]. They behave exactly the same,
+     * so it's up to contextual preference which one to use. Any combination of [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi] can be
+     * used to specify the column to rename and which name should be used instead.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.RenameColumnsSelectionDsl.Grammar]
+     *
+     * #### For Example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  { name  `[named][org.jetbrains.kotlinx.dataframe.columns.ColumnReference.named]` "Full Name" }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[expr][org.jetbrains.kotlinx.dataframe.api.expr]`  { 0 }  `[into][org.jetbrains.kotlinx.dataframe.columns.ColumnReference.into]` "zeroes" }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  { "colA"  `[named][kotlin.String.named]` Type::colB }`
+     *
+     * #### Example for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  { Type::columnA  `[named][KProperty.named]` Type::columnB }`
+     *
+     * @receiver The [KProperty] referencing the column to rename.
+     * @param [nameOf] A [KProperty] used to specify the new name of the column.
+     * @return A [ColumnReference][org.jetbrains.kotlinx.dataframe.columns.ColumnReference] to the renamed column.
+     */
+    public infix fun <C> KProperty<C>.named(nameOf: KProperty<*>): ColumnReference<C> =
+        toColumnAccessor().named(nameOf.columnName)
+
+    // endregion
+
+    // region into
+
+    /**
+     * ## Rename: `named` / `into`
+     * Renaming a column in the [ColumnsSelectionDsl][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl] is done by calling the `infix` functions
+     * [named][org.jetbrains.kotlinx.dataframe.columns.ColumnReference.named] or [into][org.jetbrains.kotlinx.dataframe.columns.ColumnReference.into]. They behave exactly the same,
+     * so it's up to contextual preference which one to use. Any combination of [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi] can be
+     * used to specify the column to rename and which name should be used instead.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.RenameColumnsSelectionDsl.Grammar]
+     *
+     * #### For Example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  { name  `[named][org.jetbrains.kotlinx.dataframe.columns.ColumnReference.named]` "Full Name" }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[expr][org.jetbrains.kotlinx.dataframe.api.expr]`  { 0 }  `[into][org.jetbrains.kotlinx.dataframe.columns.ColumnReference.into]` "zeroes" }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  { "colA"  `[named][kotlin.String.named]` Type::colB }`
+     *
+     * #### Example for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  { columnA  `[into][ColumnReference.into]` "columnB" }`
+     *
+     * @receiver The [ColumnReference] referencing the column to rename.
+     * @param [newName] A [String] used to specify the new name of the column.
+     * @return A [ColumnReference][org.jetbrains.kotlinx.dataframe.columns.ColumnReference] to the renamed column.
+     */
+    public infix fun <C> ColumnReference<C>.into(newName: String): ColumnReference<C> = named(newName)
+
+    /**
+     * ## Rename: `named` / `into`
+     * Renaming a column in the [ColumnsSelectionDsl][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl] is done by calling the `infix` functions
+     * [named][org.jetbrains.kotlinx.dataframe.columns.ColumnReference.named] or [into][org.jetbrains.kotlinx.dataframe.columns.ColumnReference.into]. They behave exactly the same,
+     * so it's up to contextual preference which one to use. Any combination of [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi] can be
+     * used to specify the column to rename and which name should be used instead.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.RenameColumnsSelectionDsl.Grammar]
+     *
+     * #### For Example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  { name  `[named][org.jetbrains.kotlinx.dataframe.columns.ColumnReference.named]` "Full Name" }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[expr][org.jetbrains.kotlinx.dataframe.api.expr]`  { 0 }  `[into][org.jetbrains.kotlinx.dataframe.columns.ColumnReference.into]` "zeroes" }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  { "colA"  `[named][kotlin.String.named]` Type::colB }`
+     *
+     * #### Example for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  { columnA  `[into][ColumnReference.into]` columnB }`
+     *
+     * @receiver The [ColumnReference] referencing the column to rename.
+     * @param [nameOf] A [ColumnReference] used to specify the new name of the column.
+     * @return A [ColumnReference][org.jetbrains.kotlinx.dataframe.columns.ColumnReference] to the renamed column.
+     */
+    public infix fun <C> ColumnReference<C>.into(nameOf: ColumnReference<*>): ColumnReference<C> = named(nameOf)
+
+    /**
+     * ## Rename: `named` / `into`
+     * Renaming a column in the [ColumnsSelectionDsl][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl] is done by calling the `infix` functions
+     * [named][org.jetbrains.kotlinx.dataframe.columns.ColumnReference.named] or [into][org.jetbrains.kotlinx.dataframe.columns.ColumnReference.into]. They behave exactly the same,
+     * so it's up to contextual preference which one to use. Any combination of [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi] can be
+     * used to specify the column to rename and which name should be used instead.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.RenameColumnsSelectionDsl.Grammar]
+     *
+     * #### For Example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  { name  `[named][org.jetbrains.kotlinx.dataframe.columns.ColumnReference.named]` "Full Name" }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[expr][org.jetbrains.kotlinx.dataframe.api.expr]`  { 0 }  `[into][org.jetbrains.kotlinx.dataframe.columns.ColumnReference.into]` "zeroes" }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  { "colA"  `[named][kotlin.String.named]` Type::colB }`
+     *
+     * #### Example for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  { columnA  `[into][ColumnReference.into]` Type::columnB }`
+     *
+     * @receiver The [ColumnReference] referencing the column to rename.
+     * @param [nameOf] A [KProperty] used to specify the new name of the column.
+     * @return A [ColumnReference][org.jetbrains.kotlinx.dataframe.columns.ColumnReference] to the renamed column.
+     */
+    public infix fun <C> ColumnReference<C>.into(nameOf: KProperty<*>): ColumnReference<C> = named(nameOf)
+
+    /**
+     * ## Rename: `named` / `into`
+     * Renaming a column in the [ColumnsSelectionDsl][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl] is done by calling the `infix` functions
+     * [named][org.jetbrains.kotlinx.dataframe.columns.ColumnReference.named] or [into][org.jetbrains.kotlinx.dataframe.columns.ColumnReference.into]. They behave exactly the same,
+     * so it's up to contextual preference which one to use. Any combination of [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi] can be
+     * used to specify the column to rename and which name should be used instead.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.RenameColumnsSelectionDsl.Grammar]
+     *
+     * #### For Example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  { name  `[named][org.jetbrains.kotlinx.dataframe.columns.ColumnReference.named]` "Full Name" }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[expr][org.jetbrains.kotlinx.dataframe.api.expr]`  { 0 }  `[into][org.jetbrains.kotlinx.dataframe.columns.ColumnReference.into]` "zeroes" }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  { "colA"  `[named][kotlin.String.named]` Type::colB }`
+     *
+     * #### Example for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  { "columnA"  `[into][String.into]` "columnB" }`
+     *
+     * @receiver The [String] referencing the column to rename.
+     * @param [newName] A [String] used to specify the new name of the column.
+     * @return A [ColumnReference][org.jetbrains.kotlinx.dataframe.columns.ColumnReference] to the renamed column.
+     */
+    public infix fun String.into(newName: String): ColumnReference<*> = named(newName)
+
+    /**
+     * ## Rename: `named` / `into`
+     * Renaming a column in the [ColumnsSelectionDsl][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl] is done by calling the `infix` functions
+     * [named][org.jetbrains.kotlinx.dataframe.columns.ColumnReference.named] or [into][org.jetbrains.kotlinx.dataframe.columns.ColumnReference.into]. They behave exactly the same,
+     * so it's up to contextual preference which one to use. Any combination of [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi] can be
+     * used to specify the column to rename and which name should be used instead.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.RenameColumnsSelectionDsl.Grammar]
+     *
+     * #### For Example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  { name  `[named][org.jetbrains.kotlinx.dataframe.columns.ColumnReference.named]` "Full Name" }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[expr][org.jetbrains.kotlinx.dataframe.api.expr]`  { 0 }  `[into][org.jetbrains.kotlinx.dataframe.columns.ColumnReference.into]` "zeroes" }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  { "colA"  `[named][kotlin.String.named]` Type::colB }`
+     *
+     * #### Example for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  { "columnA"  `[into][String.into]` columnB }`
+     *
+     * @receiver The [String] referencing the column to rename.
+     * @param [nameOf] A [ColumnReference] used to specify the new name of the column.
+     * @return A [ColumnReference][org.jetbrains.kotlinx.dataframe.columns.ColumnReference] to the renamed column.
+     */
+    public infix fun String.into(nameOf: ColumnReference<*>): ColumnReference<*> = named(nameOf)
+
+    /**
+     * ## Rename: `named` / `into`
+     * Renaming a column in the [ColumnsSelectionDsl][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl] is done by calling the `infix` functions
+     * [named][org.jetbrains.kotlinx.dataframe.columns.ColumnReference.named] or [into][org.jetbrains.kotlinx.dataframe.columns.ColumnReference.into]. They behave exactly the same,
+     * so it's up to contextual preference which one to use. Any combination of [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi] can be
+     * used to specify the column to rename and which name should be used instead.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.RenameColumnsSelectionDsl.Grammar]
+     *
+     * #### For Example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  { name  `[named][org.jetbrains.kotlinx.dataframe.columns.ColumnReference.named]` "Full Name" }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[expr][org.jetbrains.kotlinx.dataframe.api.expr]`  { 0 }  `[into][org.jetbrains.kotlinx.dataframe.columns.ColumnReference.into]` "zeroes" }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  { "colA"  `[named][kotlin.String.named]` Type::colB }`
+     *
+     * #### Example for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  { "columnA"  `[into][String.into]` Type::columnB }`
+     *
+     * @receiver The [String] referencing the column to rename.
+     * @param [nameOf] A [KProperty] used to specify the new name of the column.
+     * @return A [ColumnReference][org.jetbrains.kotlinx.dataframe.columns.ColumnReference] to the renamed column.
+     */
+    public infix fun String.into(nameOf: KProperty<*>): ColumnReference<*> = named(nameOf)
+
+    /**
+     * ## Rename: `named` / `into`
+     * Renaming a column in the [ColumnsSelectionDsl][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl] is done by calling the `infix` functions
+     * [named][org.jetbrains.kotlinx.dataframe.columns.ColumnReference.named] or [into][org.jetbrains.kotlinx.dataframe.columns.ColumnReference.into]. They behave exactly the same,
+     * so it's up to contextual preference which one to use. Any combination of [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi] can be
+     * used to specify the column to rename and which name should be used instead.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.RenameColumnsSelectionDsl.Grammar]
+     *
+     * #### For Example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  { name  `[named][org.jetbrains.kotlinx.dataframe.columns.ColumnReference.named]` "Full Name" }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[expr][org.jetbrains.kotlinx.dataframe.api.expr]`  { 0 }  `[into][org.jetbrains.kotlinx.dataframe.columns.ColumnReference.into]` "zeroes" }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  { "colA"  `[named][kotlin.String.named]` Type::colB }`
+     *
+     * #### Example for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  { Type::columnA  `[into][KProperty.into]` "columnB" }`
+     *
+     * @receiver The [KProperty] referencing the column to rename.
+     * @param [newName] A [String] used to specify the new name of the column.
+     * @return A [ColumnReference][org.jetbrains.kotlinx.dataframe.columns.ColumnReference] to the renamed column.
+     */
+    public infix fun <C> KProperty<C>.into(newName: String): ColumnReference<C> = named(newName)
+
+    /**
+     * ## Rename: `named` / `into`
+     * Renaming a column in the [ColumnsSelectionDsl][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl] is done by calling the `infix` functions
+     * [named][org.jetbrains.kotlinx.dataframe.columns.ColumnReference.named] or [into][org.jetbrains.kotlinx.dataframe.columns.ColumnReference.into]. They behave exactly the same,
+     * so it's up to contextual preference which one to use. Any combination of [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi] can be
+     * used to specify the column to rename and which name should be used instead.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.RenameColumnsSelectionDsl.Grammar]
+     *
+     * #### For Example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  { name  `[named][org.jetbrains.kotlinx.dataframe.columns.ColumnReference.named]` "Full Name" }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[expr][org.jetbrains.kotlinx.dataframe.api.expr]`  { 0 }  `[into][org.jetbrains.kotlinx.dataframe.columns.ColumnReference.into]` "zeroes" }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  { "colA"  `[named][kotlin.String.named]` Type::colB }`
+     *
+     * #### Example for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  { Type::columnA  `[into][KProperty.into]` columnB }`
+     *
+     * @receiver The [KProperty] referencing the column to rename.
+     * @param [nameOf] A [ColumnReference] used to specify the new name of the column.
+     * @return A [ColumnReference][org.jetbrains.kotlinx.dataframe.columns.ColumnReference] to the renamed column.
+     */
+    public infix fun <C> KProperty<C>.into(nameOf: ColumnReference<*>): ColumnReference<C> = named(nameOf)
+
+    /**
+     * ## Rename: `named` / `into`
+     * Renaming a column in the [ColumnsSelectionDsl][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl] is done by calling the `infix` functions
+     * [named][org.jetbrains.kotlinx.dataframe.columns.ColumnReference.named] or [into][org.jetbrains.kotlinx.dataframe.columns.ColumnReference.into]. They behave exactly the same,
+     * so it's up to contextual preference which one to use. Any combination of [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi] can be
+     * used to specify the column to rename and which name should be used instead.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.RenameColumnsSelectionDsl.Grammar]
+     *
+     * #### For Example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  { name  `[named][org.jetbrains.kotlinx.dataframe.columns.ColumnReference.named]` "Full Name" }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[expr][org.jetbrains.kotlinx.dataframe.api.expr]`  { 0 }  `[into][org.jetbrains.kotlinx.dataframe.columns.ColumnReference.into]` "zeroes" }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  { "colA"  `[named][kotlin.String.named]` Type::colB }`
+     *
+     * #### Example for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  { Type::columnA  `[into][KProperty.into]` Type::columnB }`
+     *
+     * @receiver The [KProperty] referencing the column to rename.
+     * @param [nameOf] A [KProperty] used to specify the new name of the column.
+     * @return A [ColumnReference][org.jetbrains.kotlinx.dataframe.columns.ColumnReference] to the renamed column.
+     */
+    public infix fun <C> KProperty<C>.into(nameOf: KProperty<*>): ColumnReference<C> = named(nameOf)
+
+    // endregion
+}
+
+// endregion
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/reorder.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/reorder.kt
new file mode 100644
index 000000000..16ff44e00
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/reorder.kt
@@ -0,0 +1,55 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import org.jetbrains.kotlinx.dataframe.AnyCol
+import org.jetbrains.kotlinx.dataframe.ColumnExpression
+import org.jetbrains.kotlinx.dataframe.ColumnsSelector
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.Selector
+import org.jetbrains.kotlinx.dataframe.columns.ColumnReference
+import org.jetbrains.kotlinx.dataframe.columns.toColumnSet
+import org.jetbrains.kotlinx.dataframe.impl.api.reorderImpl
+import kotlin.reflect.KProperty
+
+// region DataFrame
+
+public data class Reorder<T, C>(
+    internal val df: DataFrame<T>,
+    internal val columns: ColumnsSelector<T, C>,
+    internal val inFrameColumns: Boolean,
+) {
+    public fun <R> cast(): Reorder<T, R> = this as Reorder<T, R>
+}
+
+public fun <T, C> DataFrame<T>.reorder(selector: ColumnsSelector<T, C>): Reorder<T, C> = Reorder(this, selector, false)
+
+public fun <T, C> DataFrame<T>.reorder(vararg columns: ColumnReference<C>): Reorder<T, C> =
+    reorder { columns.toColumnSet() }
+
+public fun <T, C> DataFrame<T>.reorder(vararg columns: KProperty<C>): Reorder<T, C> = reorder { columns.toColumnSet() }
+
+public fun <T> DataFrame<T>.reorder(vararg columns: String): Reorder<T, *> = reorder { columns.toColumnSet() }
+
+public fun <T, C, V : Comparable<V>> Reorder<T, C>.by(expression: ColumnExpression<C, V>): DataFrame<T> =
+    reorderImpl(false, expression)
+
+public fun <T, C> Reorder<T, C>.byName(desc: Boolean = false): DataFrame<T> =
+    if (desc) byDesc { it.name } else by { it.name }
+
+public fun <T, C, V : Comparable<V>> Reorder<T, C>.byDesc(expression: ColumnExpression<C, V>): DataFrame<T> =
+    reorderImpl(true, expression)
+
+public fun <T, V : Comparable<V>> DataFrame<T>.reorderColumnsBy(
+    atAnyDepth: Boolean = true,
+    desc: Boolean = false,
+    expression: Selector<AnyCol, V>,
+): DataFrame<T> =
+    Reorder(
+        df = this,
+        columns = { if (atAnyDepth) colsAtAnyDepth() else all() },
+        inFrameColumns = atAnyDepth,
+    ).reorderImpl(desc, expression)
+
+public fun <T> DataFrame<T>.reorderColumnsByName(atAnyDepth: Boolean = true, desc: Boolean = false): DataFrame<T> =
+    reorderColumnsBy(atAnyDepth, desc) { name() }
+
+// endregion
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/replace.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/replace.kt
new file mode 100644
index 000000000..251c359c4
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/replace.kt
@@ -0,0 +1,61 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import org.jetbrains.kotlinx.dataframe.AnyBaseCol
+import org.jetbrains.kotlinx.dataframe.AnyCol
+import org.jetbrains.kotlinx.dataframe.ColumnsContainer
+import org.jetbrains.kotlinx.dataframe.ColumnsSelector
+import org.jetbrains.kotlinx.dataframe.DataColumn
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.columns.ColumnReference
+import org.jetbrains.kotlinx.dataframe.columns.toColumnSet
+import org.jetbrains.kotlinx.dataframe.get
+import org.jetbrains.kotlinx.dataframe.impl.api.ColumnToInsert
+import org.jetbrains.kotlinx.dataframe.impl.api.insertImpl
+import org.jetbrains.kotlinx.dataframe.impl.api.removeImpl
+import kotlin.reflect.KProperty
+
+public fun <T, C> DataFrame<T>.replace(columns: ColumnsSelector<T, C>): ReplaceClause<T, C> =
+    ReplaceClause(this, columns)
+
+public fun <T> DataFrame<T>.replace(vararg columns: String): ReplaceClause<T, Any?> = replace { columns.toColumnSet() }
+
+public fun <T, C> DataFrame<T>.replace(vararg columns: ColumnReference<C>): ReplaceClause<T, C> =
+    replace { columns.toColumnSet() }
+
+public fun <T, C> DataFrame<T>.replace(vararg columns: KProperty<C>): ReplaceClause<T, C> =
+    replace { columns.toColumnSet() }
+
+public fun <T> DataFrame<T>.replaceAll(
+    vararg valuePairs: Pair<Any?, Any?>,
+    columns: ColumnsSelector<T, *> = { colsAtAnyDepth { !it.isColumnGroup() } },
+): DataFrame<T> {
+    val map = valuePairs.toMap()
+    return update(columns).with { map[it] ?: it }
+}
+
+public class ReplaceClause<T, C>(internal val df: DataFrame<T>, internal val columns: ColumnsSelector<T, C>) {
+    override fun toString(): String = "ReplaceClause(df=$df, columns=$columns)"
+}
+
+public fun <T, C> ReplaceClause<T, C>.with(vararg columns: AnyCol): DataFrame<T> = with(columns.toList())
+
+public fun <T, C> ReplaceClause<T, C>.with(newColumns: List<AnyCol>): DataFrame<T> {
+    var index = 0
+    return with {
+        require(index < newColumns.size) {
+            "Insufficient number of new columns in 'replace': ${newColumns.size} instead of ${df[columns].size}"
+        }
+        newColumns[index++]
+    }
+}
+
+// TODO: Issue #418: breaks if running on ColumnGroup and its child
+public fun <T, C> ReplaceClause<T, C>.with(transform: ColumnsContainer<T>.(DataColumn<C>) -> AnyBaseCol): DataFrame<T> {
+    val removeResult = df.removeImpl(columns = columns)
+    val toInsert = removeResult.removedColumns.map {
+        @Suppress("UNCHECKED_CAST")
+        val newCol = transform(df, it.data.column as DataColumn<C>)
+        ColumnToInsert(it.pathFromRoot().dropLast(1) + newCol.name, newCol, it)
+    }
+    return removeResult.df.insertImpl(toInsert)
+}
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/reverse.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/reverse.kt
new file mode 100644
index 000000000..3e3f66325
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/reverse.kt
@@ -0,0 +1,18 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import org.jetbrains.kotlinx.dataframe.DataColumn
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.columns.ColumnGroup
+import org.jetbrains.kotlinx.dataframe.columns.FrameColumn
+import org.jetbrains.kotlinx.dataframe.columns.ValueColumn
+import org.jetbrains.kotlinx.dataframe.indices
+
+public fun <T> DataFrame<T>.reverse(): DataFrame<T> = get(indices.reversed())
+
+public fun <T> DataColumn<T>.reverse(): DataColumn<T> = get(indices.reversed())
+
+public fun <T> ColumnGroup<T>.reverse(): ColumnGroup<T> = get(indices.reversed())
+
+public fun <T> FrameColumn<T>.reverse(): FrameColumn<T> = get(indices.reversed())
+
+public fun <T> ValueColumn<T>.reverse(): ValueColumn<T> = get(indices.reversed())
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/schema.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/schema.kt
new file mode 100644
index 000000000..de2eef841
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/schema.kt
@@ -0,0 +1,30 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import org.jetbrains.kotlinx.dataframe.AnyFrame
+import org.jetbrains.kotlinx.dataframe.AnyRow
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.impl.owner
+import org.jetbrains.kotlinx.dataframe.impl.schema.extractSchema
+import org.jetbrains.kotlinx.dataframe.impl.schema.getSchema
+import org.jetbrains.kotlinx.dataframe.schema.DataFrameSchema
+
+// region DataRow
+
+public fun AnyRow.schema(): DataFrameSchema = owner.schema()
+
+// endregion
+
+// region DataFrame
+
+public fun AnyFrame.schema(): DataFrameSchema = extractSchema()
+
+// endregion
+
+// region GroupBy
+
+public fun GroupBy<*, *>.schema(): DataFrameSchema = toDataFrame().schema()
+
+// endregion
+
+@Suppress("UnusedReceiverParameter")
+public inline fun <reified T> DataFrame<T>.compileTimeSchema(): DataFrameSchema = getSchema(T::class)
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/select.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/select.kt
new file mode 100644
index 000000000..7f2985d2d
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/select.kt
@@ -0,0 +1,523 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import org.jetbrains.kotlinx.dataframe.AnyColumnReference
+import org.jetbrains.kotlinx.dataframe.ColumnsSelector
+import org.jetbrains.kotlinx.dataframe.DataColumn
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.DataRow
+import org.jetbrains.kotlinx.dataframe.annotations.Interpretable
+import org.jetbrains.kotlinx.dataframe.annotations.Refine
+import org.jetbrains.kotlinx.dataframe.api.Select.SelectSelectingOptions
+import org.jetbrains.kotlinx.dataframe.api.SelectColumnsSelectionDsl.Grammar
+import org.jetbrains.kotlinx.dataframe.columns.ColumnGroup
+import org.jetbrains.kotlinx.dataframe.columns.ColumnPath
+import org.jetbrains.kotlinx.dataframe.columns.ColumnReference
+import org.jetbrains.kotlinx.dataframe.columns.ColumnSet
+import org.jetbrains.kotlinx.dataframe.columns.SingleColumn
+import org.jetbrains.kotlinx.dataframe.columns.toColumnSet
+import org.jetbrains.kotlinx.dataframe.impl.columns.changePath
+import org.jetbrains.kotlinx.dataframe.impl.columns.createColumnSet
+import kotlin.reflect.KProperty
+
+// region DataFrame
+
+/**
+ * ## The Select Operation
+ *
+ * Returns a new [DataFrame] with only the columns selected by [columns].
+ *
+ * See [Selecting Columns][SelectSelectingOptions].
+ *
+ * For more information: [See `select` on the documentation website.](https://kotlin.github.io/dataframe/select.html)
+ */
+internal interface Select {
+
+    /**
+     *
+     * ## Selecting Columns
+     * Selecting columns for various operations (including but not limited to
+     * [DataFrame.select][org.jetbrains.kotlinx.dataframe.DataFrame.select], [DataFrame.update][org.jetbrains.kotlinx.dataframe.DataFrame.update], [DataFrame.gather][org.jetbrains.kotlinx.dataframe.DataFrame.gather], and [DataFrame.fillNulls][org.jetbrains.kotlinx.dataframe.DataFrame.fillNulls])
+     * can be done in the following ways:
+     * ### 1. [Columns Selection DSL][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns.Dsl.WithExample]
+     * Select or express columns using the [Columns Selection DSL][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl].
+     * (Any (combination of) [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+     *
+     * This DSL is initiated by a [Columns Selector][org.jetbrains.kotlinx.dataframe.ColumnsSelector] lambda,
+     * which operates in the context of the [Columns Selection DSL][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl] and
+     * expects you to return a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn] or [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] (so, a [ColumnsResolver][org.jetbrains.kotlinx.dataframe.columns.ColumnsResolver]).
+     * This is an entity formed by calling any (combination) of the functions
+     * in the DSL that is or can be resolved into one or more columns.
+     *
+     * #### NOTE:
+     * While you can use the [String API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi.StringApi] and [KProperties API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi.KPropertiesApi]
+     * in this DSL directly with any function, they are NOT valid return types for the
+     * [Columns Selector][org.jetbrains.kotlinx.dataframe.ColumnsSelector] lambda. You'd need to turn them into a [ColumnReference][org.jetbrains.kotlinx.dataframe.columns.ColumnReference] first, for instance
+     * with a function like [`col("name")`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.col].
+     *
+     * ### Check out: [Columns Selection DSL Grammar][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.DslGrammar]
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * [See Column Selectors on the documentation website.](https://kotlin.github.io/dataframe/columnselectors.html)
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.api.select]` { length `[and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]` age }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.api.select]`  {  `[cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`(1..5) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.api.select]`  {  `[colsOf][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[Double][Double]`>() }`
+     *
+     *
+     * #### NOTE: There's also a 'single column' variant used sometimes: [Column Selection DSL][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns.DslSingle.WithExample].
+     * ### 2. [Column names][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns.ColumnNames.WithExample]
+     * Select columns using their [column names][String]
+     * ([String API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi.StringApi]).
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.api.select]`("length", "age")`
+     *
+     * ### 3. [Column references][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns.ColumnAccessors.WithExample]
+     * Select columns using [column accessors][org.jetbrains.kotlinx.dataframe.columns.ColumnReference]
+     * ([Column Accessors API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi.ColumnAccessorsApi]).
+     *
+     * #### For example:
+     *
+     * `val length by `[column][org.jetbrains.kotlinx.dataframe.api.column]`<`[Double][Double]`>()`
+     *
+     * `val age by `[column][org.jetbrains.kotlinx.dataframe.api.column]`<`[Double][Double]`>()`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.api.select]`(length, age)`
+     *
+     * ### 4. [KProperties][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns.KProperties.WithExample]
+     * Select columns using [KProperties][KProperty] ([KProperties API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi.KPropertiesApi]).
+     *
+     * #### For example:
+     * ```kotlin
+     * data class Person(val length: Double, val age: Double)
+     * ```
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.api.select]`(Person::length, Person::age)`
+     *
+     */
+    interface SelectSelectingOptions
+}
+
+/**
+ * ## The Select Operation
+ *
+ * Returns a new [DataFrame][org.jetbrains.kotlinx.dataframe.DataFrame] with only the columns selected by [columns][org.jetbrains.kotlinx.dataframe.columns].
+ *
+ * See [Selecting Columns][org.jetbrains.kotlinx.dataframe.api.Select.SelectSelectingOptions].
+ *
+ * For more information: [See `select` on the documentation website.](https://kotlin.github.io/dataframe/select.html)
+ * ### This Select Overload
+ * Select or express columns using the [Columns Selection DSL][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl].
+ * (Any (combination of) [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+ *
+ * This DSL is initiated by a [Columns Selector][org.jetbrains.kotlinx.dataframe.ColumnsSelector] lambda,
+ * which operates in the context of the [Columns Selection DSL][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl] and
+ * expects you to return a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn] or [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] (so, a [ColumnsResolver][org.jetbrains.kotlinx.dataframe.columns.ColumnsResolver]).
+ * This is an entity formed by calling any (combination) of the functions
+ * in the DSL that is or can be resolved into one or more columns.
+ *
+ * #### NOTE:
+ * While you can use the [String API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi.StringApi] and [KProperties API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi.KPropertiesApi]
+ * in this DSL directly with any function, they are NOT valid return types for the
+ * [Columns Selector][org.jetbrains.kotlinx.dataframe.ColumnsSelector] lambda. You'd need to turn them into a [ColumnReference][org.jetbrains.kotlinx.dataframe.columns.ColumnReference] first, for instance
+ * with a function like [`col("name")`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.col].
+ *
+ * ### Check out: [Columns Selection DSL Grammar][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.DslGrammar]
+ *
+ * &nbsp;&nbsp;&nbsp;&nbsp;
+ *
+ * [See Column Selectors on the documentation website.](https://kotlin.github.io/dataframe/columnselectors.html)
+ *
+ * #### For example:
+ *
+ * `df.`[select][org.jetbrains.kotlinx.dataframe.api.select]` { length `[and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]` age }`
+ *
+ * `df.`[select][org.jetbrains.kotlinx.dataframe.api.select]`  {  `[cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`(1..5) }`
+ *
+ * `df.`[select][org.jetbrains.kotlinx.dataframe.api.select]`  {  `[colsOf][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[Double][Double]`>() }`
+ *
+ *
+ * @param [columns] The [Columns Selector][ColumnsSelector] used to select the columns of this [DataFrame].
+ */
+@Refine
+@Interpretable("Select0")
+public fun <T> DataFrame<T>.select(columns: ColumnsSelector<T, *>): DataFrame<T> = get(columns).toDataFrame().cast()
+
+/**
+ * ## The Select Operation
+ *
+ * Returns a new [DataFrame][org.jetbrains.kotlinx.dataframe.DataFrame] with only the columns selected by [columns][org.jetbrains.kotlinx.dataframe.columns].
+ *
+ * See [Selecting Columns][org.jetbrains.kotlinx.dataframe.api.Select.SelectSelectingOptions].
+ *
+ * For more information: [See `select` on the documentation website.](https://kotlin.github.io/dataframe/select.html)
+ * ### This Select Overload
+ * Select columns using [KProperties][KProperty] ([KProperties API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi.KPropertiesApi]).
+ *
+ * #### For example:
+ * ```kotlin
+ * data class Person(val length: Double, val age: Double)
+ * ```
+ *
+ * `df.`[select][org.jetbrains.kotlinx.dataframe.api.select]`(Person::length, Person::age)`
+ *
+ * @param [columns] The [KProperties][KProperty] used to select the columns of this [DataFrame].
+ */
+public fun <T> DataFrame<T>.select(vararg columns: KProperty<*>): DataFrame<T> = select { columns.toColumnSet() }
+
+/**
+ * ## The Select Operation
+ *
+ * Returns a new [DataFrame][org.jetbrains.kotlinx.dataframe.DataFrame] with only the columns selected by [columns][org.jetbrains.kotlinx.dataframe.columns].
+ *
+ * See [Selecting Columns][org.jetbrains.kotlinx.dataframe.api.Select.SelectSelectingOptions].
+ *
+ * For more information: [See `select` on the documentation website.](https://kotlin.github.io/dataframe/select.html)
+ * ### This Select Overload
+ * Select columns using their [column names][String]
+ * ([String API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi.StringApi]).
+ *
+ * #### For example:
+ *
+ * `df.`[select][org.jetbrains.kotlinx.dataframe.api.select]`("length", "age")`
+ *
+ * @param [columns] The [Column Names][String] used to select the columns of this [DataFrame].
+ */
+public fun <T> DataFrame<T>.select(vararg columns: String): DataFrame<T> = select { columns.toColumnSet() }
+
+/**
+ * ## The Select Operation
+ *
+ * Returns a new [DataFrame][org.jetbrains.kotlinx.dataframe.DataFrame] with only the columns selected by [columns][org.jetbrains.kotlinx.dataframe.columns].
+ *
+ * See [Selecting Columns][org.jetbrains.kotlinx.dataframe.api.Select.SelectSelectingOptions].
+ *
+ * For more information: [See `select` on the documentation website.](https://kotlin.github.io/dataframe/select.html)
+ * ### This Select Overload
+ * Select columns using [column accessors][org.jetbrains.kotlinx.dataframe.columns.ColumnReference]
+ * ([Column Accessors API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi.ColumnAccessorsApi]).
+ *
+ * #### For example:
+ *
+ * `val length by `[column][org.jetbrains.kotlinx.dataframe.api.column]`<`[Double][Double]`>()`
+ *
+ * `val age by `[column][org.jetbrains.kotlinx.dataframe.api.column]`<`[Double][Double]`>()`
+ *
+ * `df.`[select][org.jetbrains.kotlinx.dataframe.api.select]`(length, age)`
+ *
+ * @param [columns] The [Column Accessors][ColumnReference] used to select the columns of this [DataFrame].
+ */
+public fun <T> DataFrame<T>.select(vararg columns: AnyColumnReference): DataFrame<T> = select { columns.toColumnSet() }
+
+// endregion
+
+// region ColumnsSelectionDsl
+// NOTE: invoke overloads are inside ColumnsSelectionDsl.kt due to conflicts
+
+/**
+ * ## Select [Columns Selection DSL][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl]
+ *
+ * See [Grammar] for all functions in this interface.
+ */
+public interface SelectColumnsSelectionDsl {
+
+    /**
+     * ## Select from [ColumnGroup] Grammar
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * [(What is this notation?)][org.jetbrains.kotlinx.dataframe.documentation.DslGrammar]
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  ### Definitions:
+     *  `columnSet: `[`ColumnSet`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]`<*>`
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  `columnGroup: `[`SingleColumn`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]`<`[`DataRow`][org.jetbrains.kotlinx.dataframe.DataRow]`<*>> | `[`String`][String]`  |  `[`KProperty`][kotlin.reflect.KProperty]`<* | `[`DataRow`][org.jetbrains.kotlinx.dataframe.DataRow]`<*>> | `[`ColumnPath`][org.jetbrains.kotlinx.dataframe.columns.ColumnPath]
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  `colsSelector: `[`ColumnsSelector`][org.jetbrains.kotlinx.dataframe.ColumnsSelector]
+     *
+     *
+     *
+     *
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  ### What can be called on a [Column Group (reference)][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ColumnGroupDef]:
+     *
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  [`columnGroup`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ColumnGroupDef]
+     *
+     *  &nbsp;&nbsp;&nbsp;&nbsp;__`.`__[**`select`**][org.jetbrains.kotlinx.dataframe.api.SelectColumnsSelectionDsl.select]**`  {  `**[`colsSelector`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ColumnsSelectorDef]**` }`**
+     *
+     *  &nbsp;&nbsp;&nbsp;&nbsp;`| `[**`{`**][ColumnsSelectionDsl.select]` `[`colsSelector`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ColumnsSelectorDef]` `[**`}`**][ColumnsSelectionDsl.select]
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     */
+    public interface Grammar {
+
+        /** __`.`__[**`select`**][ColumnsSelectionDsl.select] */
+        public interface ColumnGroupName
+    }
+
+    /**
+     * ## Select from [ColumnGroup]
+     *
+     * Perform a selection of columns using the [Columns Selection DSL][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl] on
+     * any [ColumnGroup]. This is more powerful than the [cols][ColumnsSelectionDsl.cols] filter, because now all
+     * operations of the DSL are at your disposal.
+     *
+     * The scope of the new DSL instance is relative to
+     * the [ColumnGroup] you are selecting from.
+     *
+     * The [invoke][ColumnsSelectionDsl.invoke] operator is overloaded to work as a shortcut for this method.
+     *
+     * ### Check out: [Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][DataFrame.select]` { myColGroup.`[select][SingleColumn.select]`  { someCol  `[and][ColumnsSelectionDsl.and]` `[colsOf][SingleColumn.colsOf]`<`[String][String]`>() } }`
+     *
+     * `df.`[select][DataFrame.select]`  { "myGroupCol"  `[{][String.select]`  "colA" and  `[expr][ColumnsSelectionDsl.expr]`  { 0 }  `[}][String.select]` }`
+     *
+     * `df.`[select][DataFrame.select]` { "pathTo"["myGroupCol"].`[select][ColumnPath.select]` { "colA" and "colB" } }`
+     *
+     * `df.`[select][DataFrame.select]` { it["myGroupCol"].`[asColumnGroup][DataColumn.asColumnGroup]`()`[() {][SingleColumn.select]`  "colA" and "colB"  `[}][SingleColumn.select]` }`
+     *
+     * #### Examples for this overload:
+     *
+     *
+     *
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     * See also [except][ColumnsSelectionDsl.except]/[allExcept][ColumnsSelectionDsl.allColsExcept] for the inverted operation of this function.
+     *
+     * @param [selector] The [ColumnsSelector] to use for the selection.
+     * @receiver The [ColumnGroup] to select from.
+     * @throws [IllegalArgumentException] If [this] is not a [ColumnGroup].
+     * @return A [ColumnSet] containing the columns selected by [selector].
+     * @see [SingleColumn.except]
+     */
+    private interface CommonSelectDocs {
+
+        interface ExampleArg
+    }
+
+    /**
+     * ## Select from [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup]
+     *
+     * Perform a selection of columns using the [Columns Selection DSL][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl] on
+     * any [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup]. This is more powerful than the [cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols] filter, because now all
+     * operations of the DSL are at your disposal.
+     *
+     * The scope of the new DSL instance is relative to
+     * the [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup] you are selecting from.
+     *
+     * The [invoke][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.invoke] operator is overloaded to work as a shortcut for this method.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.SelectColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColGroup.`[select][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.select]`  { someCol  `[and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]` `[colsOf][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.colsOf]`<`[String][String]`>() } }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  { "myGroupCol"  `[{][kotlin.String.select]`  "colA" and  `[expr][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.expr]`  { 0 }  `[}][kotlin.String.select]` }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "pathTo"["myGroupCol"].`[select][org.jetbrains.kotlinx.dataframe.columns.ColumnPath.select]` { "colA" and "colB" } }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { it["myGroupCol"].`[asColumnGroup][org.jetbrains.kotlinx.dataframe.DataColumn.asColumnGroup]`()`[() {][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.select]`  "colA" and "colB"  `[}][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.select]` }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][DataFrame.select]` { myColGroup.`[select][SingleColumn.select]`  { someCol  `[and][ColumnsSelectionDsl.and]` `[colsOf][SingleColumn.colsOf]`<`[String][String]`>() } }`
+     *
+     * `df.`[select][DataFrame.select]`  { myColGroup  `[`{`][SingleColumn.select]`  colA  `[and][ColumnsSelectionDsl.and]`  colB  `[`}`][SingleColumn.select]` }`
+     *
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     * See also [except][org.jetbrains.kotlinx.dataframe.api.AllExceptColumnsSelectionDsl.except]/[allExcept][org.jetbrains.kotlinx.dataframe.api.AllExceptColumnsSelectionDsl.allColsExcept] for the inverted operation of this function.
+     *
+     * @param [selector] The [ColumnsSelector][org.jetbrains.kotlinx.dataframe.ColumnsSelector] to use for the selection.
+     * @receiver The [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup] to select from.
+     * @throws [IllegalArgumentException] If [this] is not a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing the columns selected by [selector].
+     * @see [SingleColumn.except]
+     */
+    public fun <C, R> SingleColumn<DataRow<C>>.select(selector: ColumnsSelector<C, R>): ColumnSet<R> =
+        selectInternal(selector)
+
+    /**
+     * ## Select from [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup]
+     *
+     * Perform a selection of columns using the [Columns Selection DSL][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl] on
+     * any [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup]. This is more powerful than the [cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols] filter, because now all
+     * operations of the DSL are at your disposal.
+     *
+     * The scope of the new DSL instance is relative to
+     * the [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup] you are selecting from.
+     *
+     * The [invoke][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.invoke] operator is overloaded to work as a shortcut for this method.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.SelectColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColGroup.`[select][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.select]`  { someCol  `[and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]` `[colsOf][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.colsOf]`<`[String][String]`>() } }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  { "myGroupCol"  `[{][kotlin.String.select]`  "colA" and  `[expr][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.expr]`  { 0 }  `[}][kotlin.String.select]` }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "pathTo"["myGroupCol"].`[select][org.jetbrains.kotlinx.dataframe.columns.ColumnPath.select]` { "colA" and "colB" } }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { it["myGroupCol"].`[asColumnGroup][org.jetbrains.kotlinx.dataframe.DataColumn.asColumnGroup]`()`[() {][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.select]`  "colA" and "colB"  `[}][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.select]` }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][DataFrame.select]` { Type::myColGroup.`[select][KProperty.select]`  { someCol  `[and][ColumnsSelectionDsl.and]` `[colsOf][SingleColumn.colsOf]`<`[String][String]`>() } }`
+     *
+     * `df.`[select][DataFrame.select]`  { DataSchemaType::myColGroup  `[`{`][KProperty.select]`  colA  `[and][ColumnsSelectionDsl.and]`  colB  `[`}`][KProperty.select]` }`
+     *
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     * See also [except][org.jetbrains.kotlinx.dataframe.api.AllExceptColumnsSelectionDsl.except]/[allExcept][org.jetbrains.kotlinx.dataframe.api.AllExceptColumnsSelectionDsl.allColsExcept] for the inverted operation of this function.
+     *
+     * @param [selector] The [ColumnsSelector][org.jetbrains.kotlinx.dataframe.ColumnsSelector] to use for the selection.
+     * @receiver The [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup] to select from.
+     * @throws [IllegalArgumentException] If [this] is not a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing the columns selected by [selector].
+     * @see [SingleColumn.except]
+     */
+    public fun <C, R> KProperty<C>.select(selector: ColumnsSelector<C, R>): ColumnSet<R> =
+        columnGroup(this).select(selector)
+
+    /**
+     * ## Select from [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup]
+     *
+     * Perform a selection of columns using the [Columns Selection DSL][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl] on
+     * any [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup]. This is more powerful than the [cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols] filter, because now all
+     * operations of the DSL are at your disposal.
+     *
+     * The scope of the new DSL instance is relative to
+     * the [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup] you are selecting from.
+     *
+     * The [invoke][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.invoke] operator is overloaded to work as a shortcut for this method.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.SelectColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColGroup.`[select][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.select]`  { someCol  `[and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]` `[colsOf][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.colsOf]`<`[String][String]`>() } }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  { "myGroupCol"  `[{][kotlin.String.select]`  "colA" and  `[expr][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.expr]`  { 0 }  `[}][kotlin.String.select]` }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "pathTo"["myGroupCol"].`[select][org.jetbrains.kotlinx.dataframe.columns.ColumnPath.select]` { "colA" and "colB" } }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { it["myGroupCol"].`[asColumnGroup][org.jetbrains.kotlinx.dataframe.DataColumn.asColumnGroup]`()`[() {][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.select]`  "colA" and "colB"  `[}][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.select]` }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][DataFrame.select]` { "myColGroup".`[select][String.select]`  { someCol  `[and][ColumnsSelectionDsl.and]` `[colsOf][SingleColumn.colsOf]`<`[String][String]`>() } }`
+     *
+     * `df.`[select][DataFrame.select]`  { "myColGroup"  `[`{`][String.select]`  colA  `[and][ColumnsSelectionDsl.and]`  colB  `[`}`][String.select]` }`
+     *
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     * See also [except][org.jetbrains.kotlinx.dataframe.api.AllExceptColumnsSelectionDsl.except]/[allExcept][org.jetbrains.kotlinx.dataframe.api.AllExceptColumnsSelectionDsl.allColsExcept] for the inverted operation of this function.
+     *
+     * @param [selector] The [ColumnsSelector][org.jetbrains.kotlinx.dataframe.ColumnsSelector] to use for the selection.
+     * @receiver The [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup] to select from.
+     * @throws [IllegalArgumentException] If [this] is not a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing the columns selected by [selector].
+     * @see [SingleColumn.except]
+     */
+    public fun <R> String.select(selector: ColumnsSelector<*, R>): ColumnSet<R> = columnGroup(this).select(selector)
+
+    /**
+     * ## Select from [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup]
+     *
+     * Perform a selection of columns using the [Columns Selection DSL][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl] on
+     * any [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup]. This is more powerful than the [cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols] filter, because now all
+     * operations of the DSL are at your disposal.
+     *
+     * The scope of the new DSL instance is relative to
+     * the [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup] you are selecting from.
+     *
+     * The [invoke][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.invoke] operator is overloaded to work as a shortcut for this method.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.SelectColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColGroup.`[select][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.select]`  { someCol  `[and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]` `[colsOf][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.colsOf]`<`[String][String]`>() } }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  { "myGroupCol"  `[{][kotlin.String.select]`  "colA" and  `[expr][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.expr]`  { 0 }  `[}][kotlin.String.select]` }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "pathTo"["myGroupCol"].`[select][org.jetbrains.kotlinx.dataframe.columns.ColumnPath.select]` { "colA" and "colB" } }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { it["myGroupCol"].`[asColumnGroup][org.jetbrains.kotlinx.dataframe.DataColumn.asColumnGroup]`()`[() {][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.select]`  "colA" and "colB"  `[}][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.select]` }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][DataFrame.select]` { "pathTo"["myColGroup"].`[select][ColumnPath.select]`  { someCol  `[and][ColumnsSelectionDsl.and]` `[colsOf][SingleColumn.colsOf]`<`[String][String]`>() } }`
+     *
+     * `df.`[select][DataFrame.select]`  { "pathTo"["myColGroup"]  `[`{`][ColumnPath.select]`  colA  `[and][ColumnsSelectionDsl.and]`  colB  `[`}`][ColumnPath.select]` }`
+     *
+     * `df.`[select][DataFrame.select]`  {  `[pathOf][pathOf]`("pathTo", "myColGroup").`[select][ColumnPath.select]`  { someCol  `[and][ColumnsSelectionDsl.and]` `[colsOf][SingleColumn.colsOf]`<`[String][String]`>() } }`
+     *
+     * `df.`[select][DataFrame.select]`  {  `[pathOf][pathOf]`("pathTo", "myColGroup")`[`() {`][ColumnPath.select]`  someCol  `[and][ColumnsSelectionDsl.and]` `[colsOf][SingleColumn.colsOf]`<`[String][String]`>() `[`}`][ColumnPath.select]` }`
+     *
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     * See also [except][org.jetbrains.kotlinx.dataframe.api.AllExceptColumnsSelectionDsl.except]/[allExcept][org.jetbrains.kotlinx.dataframe.api.AllExceptColumnsSelectionDsl.allColsExcept] for the inverted operation of this function.
+     *
+     * @param [selector] The [ColumnsSelector][org.jetbrains.kotlinx.dataframe.ColumnsSelector] to use for the selection.
+     * @receiver The [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup] to select from.
+     * @throws [IllegalArgumentException] If [this] is not a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing the columns selected by [selector].
+     * @see [SingleColumn.except]
+     */
+    public fun <R> ColumnPath.select(selector: ColumnsSelector<*, R>): ColumnSet<R> = columnGroup(this).select(selector)
+}
+
+internal fun <C, R> SingleColumn<DataRow<C>>.selectInternal(selector: ColumnsSelector<C, R>): ColumnSet<R> =
+    createColumnSet { context ->
+        this.ensureIsColumnGroup().resolveSingle(context)?.let { col ->
+            require(col.isColumnGroup()) {
+                "Column ${col.path} is not a ColumnGroup and can thus not be selected from."
+            }
+
+            col.getColumnsWithPaths(selector as ColumnsSelector<*, R>)
+                .map { it.changePath(col.path + it.path) }
+        } ?: emptyList()
+    }
+// endregion
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/shuffle.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/shuffle.kt
new file mode 100644
index 000000000..dc4f79187
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/shuffle.kt
@@ -0,0 +1,22 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import org.jetbrains.kotlinx.dataframe.DataColumn
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.indices
+import kotlin.random.Random
+
+// region DataColumn
+
+public fun <T> DataColumn<T>.shuffle(random: Random): DataColumn<T> = get(indices.shuffled(random))
+
+public fun <T> DataColumn<T>.shuffle(): DataColumn<T> = get(indices.shuffled())
+
+// endregion
+
+// region DataFrame
+
+public fun <T> DataFrame<T>.shuffle(random: Random): DataFrame<T> = getRows(indices.shuffled(random))
+
+public fun <T> DataFrame<T>.shuffle(): DataFrame<T> = getRows(indices.shuffled())
+
+// endregion
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/simplify.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/simplify.kt
new file mode 100644
index 000000000..0ec33cdb2
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/simplify.kt
@@ -0,0 +1,98 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import org.jetbrains.kotlinx.dataframe.DataColumn
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.api.SimplifyColumnsSelectionDsl.Grammar
+import org.jetbrains.kotlinx.dataframe.columns.ColumnSet
+import org.jetbrains.kotlinx.dataframe.columns.ColumnsResolver
+import org.jetbrains.kotlinx.dataframe.impl.columns.simplify
+import org.jetbrains.kotlinx.dataframe.impl.columns.transform
+
+// region ColumnsSelectionDsl
+
+/**
+ * ## Simplify [Columns Selection DSL][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl]
+ *
+ * See [Grammar] for all functions in this interface.
+ */
+public interface SimplifyColumnsSelectionDsl {
+
+    /**
+     * ## Simplify [ColumnSet] Grammar
+     *
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * [(What is this notation?)][org.jetbrains.kotlinx.dataframe.documentation.DslGrammar]
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  ### Definitions:
+     *  `columnSet: `[`ColumnSet`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]`<*>`
+     *
+     *
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  ### What can be called on a [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]:
+     *
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  [`columnSet`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ColumnSetDef]
+     *
+     *  &nbsp;&nbsp;&nbsp;&nbsp;__`.`__[**`simplify`**][org.jetbrains.kotlinx.dataframe.api.SimplifyColumnsSelectionDsl.simplify]**`()`**
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     */
+    public interface Grammar {
+
+        /** __`.`__[**`simplify`**][ColumnsSelectionDsl.simplify] */
+        public interface ColumnSetName
+    }
+
+    /**
+     * ## Simplify [ColumnSet]
+     *
+     * Given a [this] [ColumnSet], [simplify] simplifies the structure by removing columns that are already present in
+     * column groups, returning only these groups plus columns not belonging in any of the groups.
+     *
+     * In other words, this means that if a column in [this] is inside another column group in [this],
+     * it will not be included in the result.
+     *
+     * ### Check out: [Grammar]
+     *
+     * ## For example:
+     *
+     * [cols][ColumnsSelectionDsl.cols]`(a, a.b, d.c).`[simplify][SimplifyColumnsSelectionDsl.simplify]`() == `[cols][ColumnsSelectionDsl.cols]`(a, d.c)`
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * `df.`[select][DataFrame.select]`  {  `[colsAtAnyDepth][ColumnsSelectionDsl.colsAtAnyDepth]`  { "e"  `[in][String.contains]` it.`[name][DataColumn.name]` }.`[simplify][ColumnSet.simplify]`() }`
+     *
+     * @return A [ColumnSet][ColumnSet]`<`[C][C]`>` containing only the columns that are not inside any column group in [this].
+     */
+    @Suppress("UNCHECKED_CAST")
+    public fun <C> ColumnSet<C>.simplify(): ColumnSet<C> = simplifyInternal() as ColumnSet<C>
+}
+
+/**
+ * Simplifies structure by removing columns that are already present in
+ * column groups in [this].
+ *
+ * A.k.a. it gets a sub-list of columns that are roots of the trees of columns.
+ */
+internal fun ColumnsResolver<*>.simplifyInternal(): ColumnSet<*> = allColumnsInternal().transform { it.simplify() }
+
+// endregion
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/single.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/single.kt
new file mode 100644
index 000000000..aceabd066
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/single.kt
@@ -0,0 +1,359 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import org.jetbrains.kotlinx.dataframe.ColumnFilter
+import org.jetbrains.kotlinx.dataframe.DataColumn
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.DataRow
+import org.jetbrains.kotlinx.dataframe.RowExpression
+import org.jetbrains.kotlinx.dataframe.api.SingleColumnsSelectionDsl.Grammar
+import org.jetbrains.kotlinx.dataframe.columns.ColumnPath
+import org.jetbrains.kotlinx.dataframe.columns.ColumnReference
+import org.jetbrains.kotlinx.dataframe.columns.ColumnSet
+import org.jetbrains.kotlinx.dataframe.columns.ColumnsResolver
+import org.jetbrains.kotlinx.dataframe.columns.SingleColumn
+import org.jetbrains.kotlinx.dataframe.columns.asColumnSet
+import org.jetbrains.kotlinx.dataframe.columns.values
+import org.jetbrains.kotlinx.dataframe.impl.columns.TransformableColumnSet
+import org.jetbrains.kotlinx.dataframe.impl.columns.TransformableSingleColumn
+import org.jetbrains.kotlinx.dataframe.impl.columns.singleOrNullWithTransformerImpl
+import org.jetbrains.kotlinx.dataframe.impl.columns.transform
+import org.jetbrains.kotlinx.dataframe.nrow
+import kotlin.reflect.KProperty
+
+// region DataColumn
+
+public fun <C> DataColumn<C>.single(): C = values.single()
+
+// endregion
+
+// region DataFrame
+
+public fun <T> DataFrame<T>.single(): DataRow<T> =
+    when (nrow) {
+        0 -> throw NoSuchElementException("DataFrame has no rows. Use `singleOrNull`.")
+        1 -> get(0)
+        else -> throw IllegalArgumentException("DataFrame has more than one row.")
+    }
+
+public fun <T> DataFrame<T>.singleOrNull(): DataRow<T>? = rows().singleOrNull()
+
+public fun <T> DataFrame<T>.single(predicate: RowExpression<T, Boolean>): DataRow<T> =
+    rows().single { predicate(it, it) }
+
+public fun <T> DataFrame<T>.singleOrNull(predicate: RowExpression<T, Boolean>): DataRow<T>? =
+    rows().singleOrNull { predicate(it, it) }
+
+// endregion
+
+// region ColumnsSelectionDsl
+
+/**
+ * ## Single (Col) [Columns Selection DSL][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl]
+ *
+ * See [Grammar] for all functions in this interface.
+ */
+public interface SingleColumnsSelectionDsl {
+
+    /**
+     * ## Single (Col) Grammar
+     *
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * [(What is this notation?)][org.jetbrains.kotlinx.dataframe.documentation.DslGrammar]
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  ### Definitions:
+     *  `columnSet: `[`ColumnSet`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]`<*>`
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  `columnGroup: `[`SingleColumn`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]`<`[`DataRow`][org.jetbrains.kotlinx.dataframe.DataRow]`<*>> | `[`String`][String]`  |  `[`KProperty`][kotlin.reflect.KProperty]`<* | `[`DataRow`][org.jetbrains.kotlinx.dataframe.DataRow]`<*>> | `[`ColumnPath`][org.jetbrains.kotlinx.dataframe.columns.ColumnPath]
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  `condition: `[`ColumnFilter`][org.jetbrains.kotlinx.dataframe.ColumnFilter]
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  ### What can be called directly in the [Columns Selection DSL][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl]:
+     *
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  [**`single`**][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.single]`  [  `**`{ `**[`condition`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ConditionDef]**` }`**` ]`
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  ### What can be called on a [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]:
+     *
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  [`columnSet`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ColumnSetDef]
+     *
+     *  &nbsp;&nbsp;&nbsp;&nbsp;__`.`__[**`single`**][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.single]`  [  `**`{ `**[`condition`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ConditionDef]**` }`**` ]`
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  ### What can be called on a [Column Group (reference)][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ColumnGroupDef]:
+     *
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  [`columnGroup`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ColumnGroupDef]
+     *
+     *  &nbsp;&nbsp;&nbsp;&nbsp;__`.`__[**`singleCol`**][org.jetbrains.kotlinx.dataframe.api.SingleColumnsSelectionDsl.singleCol]`  [  `**`{ `**[`condition`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ConditionDef]**` }`**` ]`
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     */
+    public interface Grammar {
+
+        /** [**`single`**][ColumnsSelectionDsl.single] */
+        public interface PlainDslName
+
+        /** __`.`__[**`single`**][ColumnsSelectionDsl.single] */
+        public interface ColumnSetName
+
+        /** __`.`__[**`singleCol`**][ColumnsSelectionDsl.singleCol] */
+        public interface ColumnGroupName
+    }
+
+    /**
+     * ## Single (Col)
+     * Returns the single column from [this] that adheres to the optional given [condition].
+     * If no column adheres to the given [condition], [NoSuchElementException] is thrown.
+     * If multiple columns adhere to it, [IllegalArgumentException] is thrown.
+     *
+     * This function operates solely on columns at the top-level.
+     *
+     * NOTE: For [column groups][ColumnsSelectionDsl], `single` is named `singleCol` instead to avoid confusion.
+     *
+     * ### Check out: [Grammar]
+     *
+     * #### Examples:
+     *
+     * `df.`[select][DataFrame.select]`  {  `[single][ColumnsSelectionDsl.single]` { it.`[name][ColumnReference.name]`().`[startsWith][String.startsWith]`("order") } }`
+     *
+     * `df.`[select][DataFrame.select]` { "myColumnGroup".`[singleCol][String.singleCol]` { it.`[name][ColumnReference.name]`().`[startsWith][String.startsWith]`("order") } }`
+     *
+     * #### Examples for this overload:
+     *
+     *
+     *
+     * @param [condition] The optional [ColumnFilter] condition that the column must adhere to.
+     * @return A [SingleColumn] containing the single column that adheres to the given [condition].
+     * @throws [NoSuchElementException] if no column adheres to the given [condition].
+     * @throws [IllegalArgumentException] if more than one column adheres to the given [condition].
+     */
+    private interface CommonSingleDocs {
+
+        /** Examples key */
+        interface Examples
+    }
+
+    /**
+     * ## Single (Col)
+     * Returns the single column from [this] that adheres to the optional given [condition].
+     * If no column adheres to the given [condition], [NoSuchElementException] is thrown.
+     * If multiple columns adhere to it, [IllegalArgumentException] is thrown.
+     *
+     * This function operates solely on columns at the top-level.
+     *
+     * NOTE: For [column groups][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl], `single` is named `singleCol` instead to avoid confusion.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.SingleColumnsSelectionDsl.Grammar]
+     *
+     * #### Examples:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[single][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.single]` { it.`[name][org.jetbrains.kotlinx.dataframe.columns.ColumnReference.name]`().`[startsWith][String.startsWith]`("order") } }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "myColumnGroup".`[singleCol][kotlin.String.singleCol]` { it.`[name][org.jetbrains.kotlinx.dataframe.columns.ColumnReference.name]`().`[startsWith][String.startsWith]`("order") } }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][DataFrame.select]`  {  `[colsOf][SingleColumn.colsOf]`<`[String][String]`>().`[single][ColumnSet.single]` { it.`[name][ColumnReference.name]`().`[startsWith][String.startsWith]`("year") } }`
+     *
+     * `df.`[select][DataFrame.select]`  {  `[colsOf][SingleColumn.colsOf]`<`[Int][Int]`>().`[single][ColumnSet.single]`() }`
+     *
+     * @param [condition] The optional [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter] condition that the column must adhere to.
+     * @return A [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn] containing the single column that adheres to the given [condition].
+     * @throws [NoSuchElementException] if no column adheres to the given [condition].
+     * @throws [IllegalArgumentException] if more than one column adheres to the given [condition].
+     */
+    public fun <C> ColumnSet<C>.single(condition: ColumnFilter<C> = { true }): TransformableSingleColumn<C> =
+        singleInternal(condition)
+
+    /**
+     * ## Single (Col)
+     * Returns the single column from [this] that adheres to the optional given [condition].
+     * If no column adheres to the given [condition], [NoSuchElementException] is thrown.
+     * If multiple columns adhere to it, [IllegalArgumentException] is thrown.
+     *
+     * This function operates solely on columns at the top-level.
+     *
+     * NOTE: For [column groups][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl], `single` is named `singleCol` instead to avoid confusion.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.SingleColumnsSelectionDsl.Grammar]
+     *
+     * #### Examples:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[single][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.single]` { it.`[name][org.jetbrains.kotlinx.dataframe.columns.ColumnReference.name]`().`[startsWith][String.startsWith]`("order") } }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "myColumnGroup".`[singleCol][kotlin.String.singleCol]` { it.`[name][org.jetbrains.kotlinx.dataframe.columns.ColumnReference.name]`().`[startsWith][String.startsWith]`("order") } }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][DataFrame.select]`  {  `[single][ColumnsSelectionDsl.single]` { it.`[name][ColumnReference.name]`().`[startsWith][String.startsWith]`("year") } }`
+     *
+     * @param [condition] The optional [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter] condition that the column must adhere to.
+     * @return A [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn] containing the single column that adheres to the given [condition].
+     * @throws [NoSuchElementException] if no column adheres to the given [condition].
+     * @throws [IllegalArgumentException] if more than one column adheres to the given [condition].
+     */
+    public fun ColumnsSelectionDsl<*>.single(condition: ColumnFilter<*> = { true }): TransformableSingleColumn<*> =
+        asSingleColumn().singleCol(condition)
+
+    /**
+     * ## Single (Col)
+     * Returns the single column from [this] that adheres to the optional given [condition].
+     * If no column adheres to the given [condition], [NoSuchElementException] is thrown.
+     * If multiple columns adhere to it, [IllegalArgumentException] is thrown.
+     *
+     * This function operates solely on columns at the top-level.
+     *
+     * NOTE: For [column groups][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl], `single` is named `singleCol` instead to avoid confusion.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.SingleColumnsSelectionDsl.Grammar]
+     *
+     * #### Examples:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[single][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.single]` { it.`[name][org.jetbrains.kotlinx.dataframe.columns.ColumnReference.name]`().`[startsWith][String.startsWith]`("order") } }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "myColumnGroup".`[singleCol][kotlin.String.singleCol]` { it.`[name][org.jetbrains.kotlinx.dataframe.columns.ColumnReference.name]`().`[startsWith][String.startsWith]`("order") } }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][DataFrame.select]` { myColumnGroup.`[singleCol][SingleColumn.singleCol]`() }`
+     *
+     * @param [condition] The optional [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter] condition that the column must adhere to.
+     * @return A [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn] containing the single column that adheres to the given [condition].
+     * @throws [NoSuchElementException] if no column adheres to the given [condition].
+     * @throws [IllegalArgumentException] if more than one column adheres to the given [condition].
+     */
+    public fun SingleColumn<DataRow<*>>.singleCol(condition: ColumnFilter<*> = { true }): TransformableSingleColumn<*> =
+        this.ensureIsColumnGroup().asColumnSet().single(condition)
+
+    /**
+     * ## Single (Col)
+     * Returns the single column from [this] that adheres to the optional given [condition].
+     * If no column adheres to the given [condition], [NoSuchElementException] is thrown.
+     * If multiple columns adhere to it, [IllegalArgumentException] is thrown.
+     *
+     * This function operates solely on columns at the top-level.
+     *
+     * NOTE: For [column groups][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl], `single` is named `singleCol` instead to avoid confusion.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.SingleColumnsSelectionDsl.Grammar]
+     *
+     * #### Examples:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[single][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.single]` { it.`[name][org.jetbrains.kotlinx.dataframe.columns.ColumnReference.name]`().`[startsWith][String.startsWith]`("order") } }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "myColumnGroup".`[singleCol][kotlin.String.singleCol]` { it.`[name][org.jetbrains.kotlinx.dataframe.columns.ColumnReference.name]`().`[startsWith][String.startsWith]`("order") } }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][DataFrame.select]` { "myColumnGroup".`[singleCol][String.singleCol]` { it.`[name][ColumnReference.name]`().`[startsWith][String.startsWith]`("year") } }`
+     *
+     * @param [condition] The optional [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter] condition that the column must adhere to.
+     * @return A [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn] containing the single column that adheres to the given [condition].
+     * @throws [NoSuchElementException] if no column adheres to the given [condition].
+     * @throws [IllegalArgumentException] if more than one column adheres to the given [condition].
+     */
+    public fun String.singleCol(condition: ColumnFilter<*> = { true }): TransformableSingleColumn<*> =
+        columnGroup(this).singleCol(condition)
+
+    /**
+     * ## Single (Col)
+     * Returns the single column from [this] that adheres to the optional given [condition].
+     * If no column adheres to the given [condition], [NoSuchElementException] is thrown.
+     * If multiple columns adhere to it, [IllegalArgumentException] is thrown.
+     *
+     * This function operates solely on columns at the top-level.
+     *
+     * NOTE: For [column groups][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl], `single` is named `singleCol` instead to avoid confusion.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.SingleColumnsSelectionDsl.Grammar]
+     *
+     * #### Examples:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[single][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.single]` { it.`[name][org.jetbrains.kotlinx.dataframe.columns.ColumnReference.name]`().`[startsWith][String.startsWith]`("order") } }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "myColumnGroup".`[singleCol][kotlin.String.singleCol]` { it.`[name][org.jetbrains.kotlinx.dataframe.columns.ColumnReference.name]`().`[startsWith][String.startsWith]`("order") } }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][DataFrame.select]` { Type::myColumnGroup.`[singleCol][SingleColumn.singleCol]` { it.`[name][ColumnReference.name]`().`[startsWith][String.startsWith]`("year") } }`
+     *
+     * `df.`[select][DataFrame.select]` { DataSchemaType::myColumnGroup.`[singleCol][KProperty.singleCol]`() }`
+     *
+     * @param [condition] The optional [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter] condition that the column must adhere to.
+     * @return A [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn] containing the single column that adheres to the given [condition].
+     * @throws [NoSuchElementException] if no column adheres to the given [condition].
+     * @throws [IllegalArgumentException] if more than one column adheres to the given [condition].
+     */
+    public fun KProperty<*>.singleCol(condition: ColumnFilter<*> = { true }): TransformableSingleColumn<*> =
+        columnGroup(this).singleCol(condition)
+
+    /**
+     * ## Single (Col)
+     * Returns the single column from [this] that adheres to the optional given [condition].
+     * If no column adheres to the given [condition], [NoSuchElementException] is thrown.
+     * If multiple columns adhere to it, [IllegalArgumentException] is thrown.
+     *
+     * This function operates solely on columns at the top-level.
+     *
+     * NOTE: For [column groups][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl], `single` is named `singleCol` instead to avoid confusion.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.SingleColumnsSelectionDsl.Grammar]
+     *
+     * #### Examples:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[single][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.single]` { it.`[name][org.jetbrains.kotlinx.dataframe.columns.ColumnReference.name]`().`[startsWith][String.startsWith]`("order") } }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "myColumnGroup".`[singleCol][kotlin.String.singleCol]` { it.`[name][org.jetbrains.kotlinx.dataframe.columns.ColumnReference.name]`().`[startsWith][String.startsWith]`("order") } }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][DataFrame.select]` { "pathTo"["myColumnGroup"].`[singleCol][ColumnPath.singleCol]` { it.`[name][ColumnReference.name]`().`[startsWith][String.startsWith]`("year") } }`
+     *
+     * @param [condition] The optional [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter] condition that the column must adhere to.
+     * @return A [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn] containing the single column that adheres to the given [condition].
+     * @throws [NoSuchElementException] if no column adheres to the given [condition].
+     * @throws [IllegalArgumentException] if more than one column adheres to the given [condition].
+     */
+    public fun ColumnPath.singleCol(condition: ColumnFilter<*> = { true }): TransformableSingleColumn<*> =
+        columnGroup(this).singleCol(condition)
+}
+
+@Suppress("UNCHECKED_CAST")
+internal fun <C> ColumnsResolver<C>.singleInternal(
+    condition: ColumnFilter<C> = { true },
+): TransformableSingleColumn<C> =
+    (allColumnsInternal() as TransformableColumnSet<C>)
+        .transform { listOf(it.single(condition)) }
+        .singleOrNullWithTransformerImpl()
+
+// endregion
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/sort.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/sort.kt
new file mode 100644
index 000000000..c0b54beb5
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/sort.kt
@@ -0,0 +1,247 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import org.jetbrains.kotlinx.dataframe.DataColumn
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.DataFrameExpression
+import org.jetbrains.kotlinx.dataframe.DataRow
+import org.jetbrains.kotlinx.dataframe.Selector
+import org.jetbrains.kotlinx.dataframe.columns.ColumnGroup
+import org.jetbrains.kotlinx.dataframe.columns.ColumnReference
+import org.jetbrains.kotlinx.dataframe.columns.ColumnSet
+import org.jetbrains.kotlinx.dataframe.columns.ColumnsResolver
+import org.jetbrains.kotlinx.dataframe.columns.FrameColumn
+import org.jetbrains.kotlinx.dataframe.columns.SingleColumn
+import org.jetbrains.kotlinx.dataframe.columns.UnresolvedColumnsPolicy
+import org.jetbrains.kotlinx.dataframe.columns.ValueColumn
+import org.jetbrains.kotlinx.dataframe.columns.toColumnSet
+import org.jetbrains.kotlinx.dataframe.impl.api.SortFlag
+import org.jetbrains.kotlinx.dataframe.impl.api.addFlag
+import org.jetbrains.kotlinx.dataframe.impl.api.sortByImpl
+import org.jetbrains.kotlinx.dataframe.impl.columns.newColumnWithActualType
+import org.jetbrains.kotlinx.dataframe.impl.columns.toColumnSet
+import org.jetbrains.kotlinx.dataframe.index
+import org.jetbrains.kotlinx.dataframe.nrow
+import org.jetbrains.kotlinx.dataframe.type
+import kotlin.reflect.KProperty
+
+public interface SortDsl<out T> : ColumnsSelectionDsl<T> {
+    public fun <C> ColumnSet<C>.desc(): ColumnSet<C> = addFlag(SortFlag.Reversed)
+
+    public fun <C> SingleColumn<C>.desc(): SingleColumn<C> = addFlag(SortFlag.Reversed).single()
+
+    public fun String.desc(): SingleColumn<Comparable<*>?> = invoke<Comparable<*>>().desc()
+
+    public fun <C> KProperty<C>.desc(): SingleColumn<C> = toColumnAccessor().desc()
+
+    public fun <C> ColumnSet<C?>.nullsLast(flag: Boolean = true): ColumnSet<C?> =
+        if (flag) addFlag(SortFlag.NullsLast) else this
+
+    public fun <C> SingleColumn<C?>.nullsLast(flag: Boolean = true): SingleColumn<C?> =
+        if (flag) addFlag(SortFlag.NullsLast).single() else this
+
+    public fun String.nullsLast(flag: Boolean = true): SingleColumn<Comparable<*>?> =
+        invoke<Comparable<*>>().nullsLast(flag)
+
+    public fun <C> KProperty<C?>.nullsLast(flag: Boolean = true): SingleColumn<C?> = toColumnAccessor().nullsLast(flag)
+}
+
+/**
+ * [SortColumnsSelector] is used to express or select multiple columns to sort by, represented by [ColumnsResolver]`<C>`,
+ * using the context of [SortDsl]`<T>` as `this` and `it`.
+ *
+ * So:
+ * ```kotlin
+ * SortDsl<T>.(it: SortDsl<T>) -> ColumnSet<C>
+ * ```
+ */
+public typealias SortColumnsSelector<T, C> = Selector<SortDsl<T>, ColumnsResolver<C>>
+
+// region DataColumn
+
+public fun <T : Comparable<T>> DataColumn<T>.sort(): ValueColumn<T> =
+    DataColumn.createValueColumn(name, values().sorted(), type, defaultValue = defaultValue())
+
+public fun <T : Comparable<T>> DataColumn<T>.sortDesc(): ValueColumn<T> =
+    DataColumn.createValueColumn(name, values().sortedDescending(), type, defaultValue = defaultValue())
+
+/**
+ * ## Sort [DataColumn] With
+ *
+ * This function returns the sorted version of the current [ValueColumn], [FrameColumn], or [ColumnGroup] based
+ * on the given [Comparator]. The [comparator] can either be given as an instance of [Comparator], or directly
+ * as a lambda.
+ *
+ * #### For example
+ *
+ * `df`[`[`][DataFrame.get]`"price"`[`]`][DataFrame.get]`.`[sortWith][sortWith]` { a, b -> a - b }`
+ *
+ *
+ * &nbsp;&nbsp;&nbsp;&nbsp;
+ *
+ * `df.`[select][DataFrame.select]` {`
+ *
+ * &nbsp;&nbsp;&nbsp;&nbsp;`name.`[sortWith][sortWith]`(myComparator) `[and][ColumnsSelectionDsl.and]` `[allAfter][ColumnsSelectionDsl.allAfter]`(name)`
+ *
+ * `}`
+ *
+ * @receiver The [DataColumn] to sort. This can be either a [ValueColumn], [FrameColumn], or [ColumnGroup] and will
+ *   dictate the return type of the function.
+ * @param [comparator] The [Comparator] to use for sorting the [DataColumn]. This can either be a [Comparator]<[T]> or
+ *   a lambda of type `(`[T][T]`, `[T][T]`) -> `[Int][Int].
+ * @return The sorted [DataColumn] [this] of the same type as the receiver.
+ */
+private interface CommonDataColumnSortWithDocs
+
+/** ## Sort [DataColumn][org.jetbrains.kotlinx.dataframe.DataColumn] With
+ *
+ * This function returns the sorted version of the current [ValueColumn][org.jetbrains.kotlinx.dataframe.columns.ValueColumn], [FrameColumn][org.jetbrains.kotlinx.dataframe.columns.FrameColumn], or [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup] based
+ * on the given [Comparator]. The [comparator] can either be given as an instance of [Comparator], or directly
+ * as a lambda.
+ *
+ * #### For example
+ *
+ * `df`[`[`][org.jetbrains.kotlinx.dataframe.DataFrame.get]`"price"`[`]`][org.jetbrains.kotlinx.dataframe.DataFrame.get]`.`[sortWith][org.jetbrains.kotlinx.dataframe.api.sortWith]` { a, b -> a - b }`
+ *
+ *
+ * &nbsp;&nbsp;&nbsp;&nbsp;
+ *
+ * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` {`
+ *
+ * &nbsp;&nbsp;&nbsp;&nbsp;`name.`[sortWith][org.jetbrains.kotlinx.dataframe.api.sortWith]`(myComparator) `[and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]` `[allAfter][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.allAfter]`(name)`
+ *
+ * `}`
+ *
+ * @receiver The [DataColumn][org.jetbrains.kotlinx.dataframe.DataColumn] to sort. This can be either a [ValueColumn][org.jetbrains.kotlinx.dataframe.columns.ValueColumn], [FrameColumn][org.jetbrains.kotlinx.dataframe.columns.FrameColumn], or [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup] and will
+ *   dictate the return type of the function.
+ * @param [comparator] The [Comparator] to use for sorting the [DataColumn][org.jetbrains.kotlinx.dataframe.DataColumn]. This can either be a [Comparator]<[T]> or
+ *   a lambda of type `(`[T][T]`, `[T][T]`) -> `[Int][Int].
+ * @return The sorted [DataColumn][org.jetbrains.kotlinx.dataframe.DataColumn] [this] of the same type as the receiver. */
+public fun <T, C : DataColumn<T>> C.sortWith(comparator: Comparator<T>): C =
+    DataColumn.create(name, values().sortedWith(comparator), type) as C
+
+/** ## Sort [DataColumn][org.jetbrains.kotlinx.dataframe.DataColumn] With
+ *
+ * This function returns the sorted version of the current [ValueColumn][org.jetbrains.kotlinx.dataframe.columns.ValueColumn], [FrameColumn][org.jetbrains.kotlinx.dataframe.columns.FrameColumn], or [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup] based
+ * on the given [Comparator]. The [comparator] can either be given as an instance of [Comparator], or directly
+ * as a lambda.
+ *
+ * #### For example
+ *
+ * `df`[`[`][org.jetbrains.kotlinx.dataframe.DataFrame.get]`"price"`[`]`][org.jetbrains.kotlinx.dataframe.DataFrame.get]`.`[sortWith][org.jetbrains.kotlinx.dataframe.api.sortWith]` { a, b -> a - b }`
+ *
+ *
+ * &nbsp;&nbsp;&nbsp;&nbsp;
+ *
+ * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` {`
+ *
+ * &nbsp;&nbsp;&nbsp;&nbsp;`name.`[sortWith][org.jetbrains.kotlinx.dataframe.api.sortWith]`(myComparator) `[and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]` `[allAfter][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.allAfter]`(name)`
+ *
+ * `}`
+ *
+ * @receiver The [DataColumn][org.jetbrains.kotlinx.dataframe.DataColumn] to sort. This can be either a [ValueColumn][org.jetbrains.kotlinx.dataframe.columns.ValueColumn], [FrameColumn][org.jetbrains.kotlinx.dataframe.columns.FrameColumn], or [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup] and will
+ *   dictate the return type of the function.
+ * @param [comparator] The [Comparator] to use for sorting the [DataColumn][org.jetbrains.kotlinx.dataframe.DataColumn]. This can either be a [Comparator]<[T]> or
+ *   a lambda of type `(`[T][T]`, `[T][T]`) -> `[Int][Int].
+ * @return The sorted [DataColumn][org.jetbrains.kotlinx.dataframe.DataColumn] [this] of the same type as the receiver. */
+public fun <T, C : DataColumn<T>> C.sortWith(comparator: (T, T) -> Int): C = sortWith(Comparator(comparator))
+
+// endregion
+
+// region DataFrame
+
+public fun <T, C> DataFrame<T>.sortBy(columns: SortColumnsSelector<T, C>): DataFrame<T> =
+    sortByImpl(UnresolvedColumnsPolicy.Fail, columns)
+
+public fun <T> DataFrame<T>.sortBy(vararg cols: ColumnReference<*>): DataFrame<T> = sortBy { cols.toColumnSet() }
+
+public fun <T> DataFrame<T>.sortBy(vararg cols: String): DataFrame<T> = sortBy { cols.toColumnSet() }
+
+public fun <T> DataFrame<T>.sortBy(vararg cols: KProperty<Comparable<*>?>): DataFrame<T> = sortBy { cols.toColumnSet() }
+
+public fun <T> DataFrame<T>.sortWith(comparator: Comparator<DataRow<T>>): DataFrame<T> {
+    val permutation = rows().sortedWith(comparator).map { it.index }
+    return this[permutation]
+}
+
+public fun <T> DataFrame<T>.sortWith(comparator: (DataRow<T>, DataRow<T>) -> Int): DataFrame<T> =
+    sortWith(Comparator(comparator))
+
+public fun <T, C> DataFrame<T>.sortByDesc(columns: SortColumnsSelector<T, C>): DataFrame<T> {
+    val set = columns.toColumnSet()
+    return sortByImpl { set.desc() }
+}
+
+public fun <T, C> DataFrame<T>.sortByDesc(vararg columns: KProperty<Comparable<C>?>): DataFrame<T> =
+    sortByDesc { columns.toColumnSet() }
+
+public fun <T> DataFrame<T>.sortByDesc(vararg columns: String): DataFrame<T> = sortByDesc { columns.toColumnSet() }
+
+public fun <T> DataFrame<T>.sortByDesc(vararg columns: ColumnReference<*>): DataFrame<T> =
+    sortByDesc { columns.toColumnSet() }
+
+// endregion
+
+// region GroupBy
+
+public fun <T, G> GroupBy<T, G>.sortBy(vararg cols: String): GroupBy<T, G> = sortBy { cols.toColumnSet() }
+
+public fun <T, G> GroupBy<T, G>.sortBy(vararg cols: ColumnReference<*>): GroupBy<T, G> = sortBy { cols.toColumnSet() }
+
+public fun <T, G> GroupBy<T, G>.sortBy(vararg cols: KProperty<Comparable<*>?>): GroupBy<T, G> =
+    sortBy { cols.toColumnSet() }
+
+public fun <T, G, C> GroupBy<T, G>.sortBy(selector: SortColumnsSelector<G, C>): GroupBy<T, G> = sortByImpl(selector)
+
+public fun <T, G> GroupBy<T, G>.sortByDesc(vararg cols: String): GroupBy<T, G> = sortByDesc { cols.toColumnSet() }
+
+public fun <T, G> GroupBy<T, G>.sortByDesc(vararg cols: ColumnReference<*>): GroupBy<T, G> =
+    sortByDesc { cols.toColumnSet() }
+
+public fun <T, G> GroupBy<T, G>.sortByDesc(vararg cols: KProperty<Comparable<*>?>): GroupBy<T, G> =
+    sortByDesc { cols.toColumnSet() }
+
+public fun <T, G, C> GroupBy<T, G>.sortByDesc(selector: SortColumnsSelector<G, C>): GroupBy<T, G> {
+    val set = selector.toColumnSet()
+    return sortByImpl { set.desc() }
+}
+
+private fun <T, G, C> GroupBy<T, G>.createColumnFromGroupExpression(
+    receiver: ColumnsSelectionDsl<T>,
+    expression: DataFrameExpression<G, C>,
+): DataColumn<C?> =
+    receiver.newColumnWithActualType("") { row ->
+        val group = row[groups]
+        expression(group, group)
+    }
+
+public fun <T, G, C> GroupBy<T, G>.sortByGroup(
+    nullsLast: Boolean = false,
+    expression: DataFrameExpression<G, C>,
+): GroupBy<T, G> =
+    toDataFrame().sortBy {
+        createColumnFromGroupExpression(this, expression).nullsLast(nullsLast)
+    }.asGroupBy(groups)
+
+public fun <T, G, C> GroupBy<T, G>.sortByGroupDesc(
+    nullsLast: Boolean = false,
+    expression: DataFrameExpression<G, C>,
+): GroupBy<T, G> =
+    toDataFrame().sortBy {
+        createColumnFromGroupExpression(this, expression).desc().nullsLast(nullsLast)
+    }.asGroupBy(groups)
+
+public fun <T, G> GroupBy<T, G>.sortByCountAsc(): GroupBy<T, G> = sortByGroup { nrow }
+
+public fun <T, G> GroupBy<T, G>.sortByCount(): GroupBy<T, G> = sortByGroupDesc { nrow }
+
+public fun <T, G> GroupBy<T, G>.sortByKeyDesc(nullsLast: Boolean = false): GroupBy<T, G> =
+    toDataFrame()
+        .sortBy { keys.columns().toColumnSet().desc().nullsLast(nullsLast) }
+        .asGroupBy(groups)
+
+public fun <T, G> GroupBy<T, G>.sortByKey(nullsLast: Boolean = false): GroupBy<T, G> =
+    toDataFrame()
+        .sortBy { keys.columns().toColumnSet().nullsLast(nullsLast) }
+        .asGroupBy(groups)
+
+// endregion
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/split.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/split.kt
new file mode 100644
index 000000000..56fa8d23a
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/split.kt
@@ -0,0 +1,294 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import org.intellij.lang.annotations.Language
+import org.jetbrains.kotlinx.dataframe.AnyFrame
+import org.jetbrains.kotlinx.dataframe.ColumnsSelector
+import org.jetbrains.kotlinx.dataframe.DataColumn
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.DataRow
+import org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor
+import org.jetbrains.kotlinx.dataframe.columns.ColumnReference
+import org.jetbrains.kotlinx.dataframe.columns.ColumnSet
+import org.jetbrains.kotlinx.dataframe.columns.ColumnWithPath
+import org.jetbrains.kotlinx.dataframe.columns.toColumnSet
+import org.jetbrains.kotlinx.dataframe.impl.api.splitDefault
+import org.jetbrains.kotlinx.dataframe.impl.api.splitImpl
+import org.jetbrains.kotlinx.dataframe.impl.api.withRowCellImpl
+import org.jetbrains.kotlinx.dataframe.impl.asList
+import org.jetbrains.kotlinx.dataframe.impl.columnName
+import org.jetbrains.kotlinx.dataframe.impl.getListType
+import kotlin.reflect.KProperty
+import kotlin.reflect.KType
+import kotlin.reflect.typeOf
+
+public fun <T, C> DataFrame<T>.split(columns: ColumnsSelector<T, C?>): Split<T, C> = Split(this, columns)
+
+public fun <T> DataFrame<T>.split(vararg columns: String): Split<T, Any> = split { columns.toColumnSet() }
+
+public fun <T, C> DataFrame<T>.split(vararg columns: ColumnReference<C?>): Split<T, C> = split { columns.toColumnSet() }
+
+public fun <T, C> DataFrame<T>.split(vararg columns: KProperty<C?>): Split<T, C> = split { columns.toColumnSet() }
+
+public class Split<T, C>(internal val df: DataFrame<T>, internal val columns: ColumnsSelector<T, C?>) {
+    public fun <P> cast(): Split<T, P> = this as Split<T, P>
+
+    override fun toString(): String = "Split(df=$df, columns=$columns)"
+}
+
+public data class SplitWithTransform<T, C, R>(
+    internal val df: DataFrame<T>,
+    internal val columns: ColumnsSelector<T, C?>,
+    internal val inward: Boolean,
+    internal val tartypeOf: KType,
+    internal val default: R? = null,
+    internal val transform: DataRow<T>.(C) -> Iterable<R>,
+)
+
+public typealias ColumnNamesGenerator<C> = ColumnWithPath<C>.(extraColumnIndex: Int) -> String
+
+// region default
+
+public inline fun <T, C : Iterable<R>, reified R> Split<T, C>.default(value: R?): SplitWithTransform<T, C, R> =
+    by { it }.default(value)
+
+public fun <T> Split<T, String>.default(value: String?): SplitWithTransform<T, String, String> =
+    by { it.splitDefault() }.default(value)
+
+public fun <T, C, R> SplitWithTransform<T, C, R>.default(value: R?): SplitWithTransform<T, C, R> = copy(default = value)
+
+// endregion
+
+// region by
+
+public inline fun <T, C, reified R> Split<T, C>.by(
+    noinline splitter: DataRow<T>.(C) -> Iterable<R>,
+): SplitWithTransform<T, C, R> = by(typeOf<R>(), splitter)
+
+public fun <T, C> Split<T, C>.by(
+    vararg delimiters: Char,
+    trim: Boolean = true,
+    ignoreCase: Boolean = false,
+    limit: Int = 0,
+): SplitWithTransform<T, C, String> =
+    by {
+        it.toString().split(*delimiters, ignoreCase = ignoreCase, limit = limit).let {
+            if (trim) it.map { it.trim() } else it
+        }
+    }
+
+public fun <T, C> Split<T, C>.by(
+    regex: Regex,
+    trim: Boolean = true,
+    limit: Int = 0,
+): SplitWithTransform<T, C, String> =
+    by {
+        it.toString().split(regex, limit = limit).let {
+            if (trim) it.map { it.trim() } else it
+        }
+    }
+
+public fun <T, C> Split<T, C>.by(
+    vararg delimiters: String,
+    trim: Boolean = true,
+    ignoreCase: Boolean = false,
+    limit: Int = 0,
+): SplitWithTransform<T, C, String> =
+    by {
+        it.toString().split(*delimiters, ignoreCase = ignoreCase, limit = limit).let {
+            if (trim) it.map { it.trim() } else it
+        }
+    }
+
+@PublishedApi
+internal fun <T, C, R> Split<T, C>.by(
+    type: KType,
+    splitter: DataRow<T>.(C) -> Iterable<R>,
+): SplitWithTransform<T, C, R> =
+    SplitWithTransform(df, columns, false, type) {
+        if (it == null) emptyList() else splitter(it).asList()
+    }
+
+// endregion
+
+// region match
+
+public fun <T, C : String?> Split<T, C>.match(
+    @Language("RegExp") regex: String,
+): SplitWithTransform<T, C, String?> = match(regex.toRegex())
+
+public fun <T, C : String?> Split<T, C>.match(regex: Regex): SplitWithTransform<T, C, String?> =
+    by {
+        it?.let {
+            regex.matchEntire(it)
+                ?.groups
+                ?.drop(1)
+                ?.map { it?.value }
+        } ?: emptyList<String>()
+    }
+
+// endregion
+
+internal fun <T, C> Split<T, C>.toDataFrame(): DataFrame<T> =
+    by {
+        when (it) {
+            is List<*> -> it
+            is AnyFrame -> it.rows()
+            else -> listOf(it)
+        }
+    }.into()
+
+// region into
+
+public fun <T, C, R> SplitWithTransform<T, C, R>.into(
+    firstName: ColumnAccessor<*>,
+    vararg otherNames: ColumnAccessor<*>,
+): DataFrame<T> = into(listOf(firstName.name()) + otherNames.map { it.name() })
+
+public fun <T, C, R> SplitWithTransform<T, C, R>.into(
+    firstName: KProperty<*>,
+    vararg otherNames: KProperty<*>,
+): DataFrame<T> = into(listOf(firstName.columnName) + otherNames.map { it.columnName })
+
+public fun <T, C, R> SplitWithTransform<T, C, R>.into(
+    vararg names: String,
+    extraNamesGenerator: (ColumnWithPath<C>.(extraColumnIndex: Int) -> String)? = null,
+): DataFrame<T> = into(names.toList(), extraNamesGenerator)
+
+public fun <T, C, R> SplitWithTransform<T, C, R>.into(
+    names: List<String>,
+    extraNamesGenerator: (ColumnWithPath<C>.(extraColumnIndex: Int) -> String)? = null,
+): DataFrame<T> =
+    splitImpl(this) { numberOfNewCols ->
+        if (extraNamesGenerator != null && names.size < numberOfNewCols) {
+            names + (1..(numberOfNewCols - names.size)).map { extraNamesGenerator(this, it) }
+        } else {
+            names
+        }
+    }
+
+public fun <T, C : Iterable<*>> Split<T, C>.into(
+    vararg names: String,
+    extraNamesGenerator: ColumnNamesGenerator<C>? = null,
+): DataFrame<T> = by { it }.into(names.toList(), extraNamesGenerator)
+
+@JvmName("splitDataFrameInto")
+public fun <T, C> Split<T, DataFrame<C>>.into(
+    vararg names: String,
+    extraNamesGenerator: ColumnNamesGenerator<DataFrame<C>>? = null,
+): DataFrame<T> = by { it.rows() }.into(names.toList(), extraNamesGenerator)
+
+public fun <T, A, B> Split<T, Pair<A, B>>.into(firstCol: String, secondCol: String): DataFrame<T> =
+    by { listOf(it.first, it.second) }.into(firstCol, secondCol)
+
+public inline fun <T, reified A, reified B> Split<T, Pair<A, B>>.into(
+    firstCol: ColumnAccessor<A>,
+    secondCol: ColumnAccessor<B>,
+): DataFrame<T> = by { listOf(it.first, it.second) }.into(firstCol, secondCol)
+
+@JvmName("intoTC")
+public fun <T> Split<T, String>.into(
+    vararg names: String,
+    extraNamesGenerator: (ColumnWithPath<String>.(extraColumnIndex: Int) -> String)? = null,
+): DataFrame<T> = by { it.splitDefault() }.into(names.toList(), extraNamesGenerator)
+
+// endregion
+
+// region inward
+
+public fun <T, C, R> SplitWithTransform<T, C, R>.inward(
+    names: Iterable<String>,
+    extraNamesGenerator: ColumnNamesGenerator<C>? = null,
+): DataFrame<T> = copy(inward = true).into(names.toList(), extraNamesGenerator)
+
+public fun <T, C, R> SplitWithTransform<T, C, R>.inward(
+    vararg names: String,
+    extraNamesGenerator: ColumnNamesGenerator<C>? = null,
+): DataFrame<T> = inward(names.toList(), extraNamesGenerator)
+
+public fun <T, C, R> SplitWithTransform<T, C, R>.inward(
+    firstName: ColumnAccessor<*>,
+    vararg otherNames: ColumnAccessor<*>,
+): DataFrame<T> = inward(listOf(firstName.name()) + otherNames.map { it.name() })
+
+public fun <T, C, R> SplitWithTransform<T, C, R>.inward(
+    firstName: KProperty<*>,
+    vararg otherNames: KProperty<*>,
+): DataFrame<T> = inward(listOf(firstName.columnName) + otherNames.map { it.columnName })
+
+public inline fun <T, C : Iterable<R>, reified R> Split<T, C>.inward(
+    vararg names: String,
+    noinline extraNamesGenerator: ColumnNamesGenerator<C>? = null,
+): DataFrame<T> = by { it }.inward(names.toList(), extraNamesGenerator)
+
+@JvmName("splitDataFrameInward")
+public fun <T, C : DataFrame<R>, R> Split<T, C>.inward(
+    vararg names: String,
+    extraNamesGenerator: ColumnNamesGenerator<C>? = null,
+): DataFrame<T> = by { it.rows() }.inward(names.toList(), extraNamesGenerator)
+
+public fun <T, A, B> Split<T, Pair<A, B>>.inward(firstCol: String, secondCol: String): DataFrame<T> =
+    by { listOf(it.first, it.second) }.inward(firstCol, secondCol)
+
+public inline fun <T, reified A, reified B> Split<T, Pair<A, B>>.inward(
+    firstCol: ColumnAccessor<A>,
+    secondCol: ColumnAccessor<B>,
+): DataFrame<T> = by { listOf(it.first, it.second) }.inward(firstCol, secondCol)
+
+@JvmName("inwardTC")
+public fun <T> Split<T, String>.inward(
+    vararg names: String,
+    extraNamesGenerator: (ColumnWithPath<String>.(extraColumnIndex: Int) -> String)? = null,
+): DataFrame<T> = by { it.splitDefault() }.inward(names.toList(), extraNamesGenerator)
+
+// endregion
+
+// region intoColumns
+
+public fun <T, C : AnyFrame> Split<T, C>.intoColumns(): DataFrame<T> =
+    df.convert(columns).with {
+        when {
+            it == null -> null
+            it.isEmpty() -> DataRow.empty
+            else -> it.implode { all() }.single()
+        }
+    }
+
+// endregion
+
+// region intoRows
+
+@JvmName("intoRowsTC")
+public inline fun <T, C : Iterable<R>, reified R> Split<T, C>.intoRows(dropEmpty: Boolean = true): DataFrame<T> =
+    by { it }
+        .intoRows(dropEmpty)
+
+@JvmName("intoRowsFrame")
+public fun <T, C : AnyFrame> Split<T, C>.intoRows(dropEmpty: Boolean = true): DataFrame<T> =
+    by { it.rows() }.intoRows(dropEmpty)
+
+internal fun <T, C, R> Convert<T, C?>.splitInplace(type: KType, transform: DataRow<T>.(C) -> Iterable<R>) =
+    withRowCellImpl(getListType(type), Infer.None) { if (it == null) emptyList() else transform(it).asList() }
+
+public fun <T, C, R> SplitWithTransform<T, C, R>.intoRows(dropEmpty: Boolean = true): DataFrame<T> {
+    val paths = df.getColumnPaths(columns).toColumnSet()
+    return df.convert { paths as ColumnSet<C?> }.splitInplace(tartypeOf, transform).explode(dropEmpty) { paths }
+}
+
+// endregion
+
+// region inplace
+
+@JvmName("inplaceTC")
+public inline fun <T, C : Iterable<R>, reified R> Split<T, C>.inplace(): DataFrame<T> = by { it }.inplace()
+
+public fun <T, C, R> SplitWithTransform<T, C, R>.inplace(): DataFrame<T> =
+    df.convert(columns).splitInplace(tartypeOf, transform)
+
+// endregion
+
+// region DataColumn
+
+public fun DataColumn<Iterable<*>>.splitInto(vararg names: String): AnyFrame =
+    toDataFrame().split { this@splitInto }.into(*names)
+
+// endregion
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/std.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/std.kt
new file mode 100644
index 000000000..af6a07ca7
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/std.kt
@@ -0,0 +1,301 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import org.jetbrains.kotlinx.dataframe.AnyRow
+import org.jetbrains.kotlinx.dataframe.ColumnsSelector
+import org.jetbrains.kotlinx.dataframe.DataColumn
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.DataRow
+import org.jetbrains.kotlinx.dataframe.RowExpression
+import org.jetbrains.kotlinx.dataframe.aggregation.ColumnsForAggregateSelector
+import org.jetbrains.kotlinx.dataframe.columns.ColumnReference
+import org.jetbrains.kotlinx.dataframe.columns.toColumnSet
+import org.jetbrains.kotlinx.dataframe.columns.toColumnsSetOf
+import org.jetbrains.kotlinx.dataframe.impl.aggregation.aggregators.Aggregators
+import org.jetbrains.kotlinx.dataframe.impl.aggregation.aggregators.cast2
+import org.jetbrains.kotlinx.dataframe.impl.aggregation.modes.aggregateAll
+import org.jetbrains.kotlinx.dataframe.impl.aggregation.modes.aggregateFor
+import org.jetbrains.kotlinx.dataframe.impl.aggregation.modes.aggregateOf
+import org.jetbrains.kotlinx.dataframe.impl.aggregation.modes.of
+import org.jetbrains.kotlinx.dataframe.impl.aggregation.numberColumns
+import org.jetbrains.kotlinx.dataframe.math.std
+import kotlin.reflect.KProperty
+import kotlin.reflect.typeOf
+
+// region DataColumn
+
+public fun <T : Number> DataColumn<T?>.std(skipNA: Boolean = skipNA_default, ddof: Int = ddof_default): Double =
+    Aggregators.std(skipNA, ddof).aggregate(this) ?: .0
+
+public inline fun <T, reified R : Number> DataColumn<T>.stdOf(
+    skipNA: Boolean = skipNA_default,
+    ddof: Int = ddof_default,
+    noinline expression: (T) -> R?,
+): Double = Aggregators.std(skipNA, ddof).cast2<R?, Double>().aggregateOf(this, expression) ?: .0
+
+// endregion
+
+// region DataRow
+
+public fun AnyRow.rowStd(skipNA: Boolean = skipNA_default, ddof: Int = ddof_default): Double =
+    values().filterIsInstance<Number>().map { it.toDouble() }.std(skipNA, ddof)
+
+public inline fun <reified T : Number> AnyRow.rowStdOf(ddof: Int = ddof_default): Double =
+    values()
+        .filterIsInstance<T>()
+        .std(
+            type = typeOf<T>(),
+            ddof = ddof,
+        )
+
+// endregion
+
+// region DataFrame
+
+public fun <T> DataFrame<T>.std(skipNA: Boolean = skipNA_default, ddof: Int = ddof_default): DataRow<T> =
+    stdFor(skipNA, ddof, numberColumns())
+
+public fun <T> DataFrame<T>.stdFor(
+    skipNA: Boolean = skipNA_default,
+    ddof: Int = ddof_default,
+    columns: ColumnsForAggregateSelector<T, Number?>,
+): DataRow<T> = Aggregators.std(skipNA, ddof).aggregateFor(this, columns)
+
+public fun <T> DataFrame<T>.stdFor(
+    vararg columns: String,
+    skipNA: Boolean = skipNA_default,
+    ddof: Int = ddof_default,
+): DataRow<T> = stdFor(skipNA, ddof) { columns.toColumnsSetOf() }
+
+public fun <T, C : Number> DataFrame<T>.stdFor(
+    vararg columns: ColumnReference<C?>,
+    skipNA: Boolean = skipNA_default,
+    ddof: Int = ddof_default,
+): DataRow<T> = stdFor(skipNA, ddof) { columns.toColumnSet() }
+
+public fun <T, C : Number> DataFrame<T>.stdFor(
+    vararg columns: KProperty<C?>,
+    skipNA: Boolean = skipNA_default,
+    ddof: Int = ddof_default,
+): DataRow<T> = stdFor(skipNA, ddof) { columns.toColumnSet() }
+
+public fun <T> DataFrame<T>.std(
+    skipNA: Boolean = skipNA_default,
+    ddof: Int = ddof_default,
+    columns: ColumnsSelector<T, Number?>,
+): Double = Aggregators.std(skipNA, ddof).aggregateAll(this, columns) ?: .0
+
+public fun <T> DataFrame<T>.std(vararg columns: ColumnReference<Number?>): Double = std { columns.toColumnSet() }
+
+public fun <T> DataFrame<T>.std(vararg columns: String): Double = std { columns.toColumnsSetOf() }
+
+public fun <T> DataFrame<T>.std(vararg columns: KProperty<Number?>): Double = std { columns.toColumnSet() }
+
+public inline fun <T, reified R : Number> DataFrame<T>.stdOf(
+    skipNA: Boolean = skipNA_default,
+    ddof: Int = ddof_default,
+    crossinline expression: RowExpression<T, R?>,
+): Double = Aggregators.std(skipNA, ddof).of(this, expression) ?: .0
+
+// endregion
+
+// region GroupBy
+
+public fun <T> Grouped<T>.std(skipNA: Boolean = skipNA_default, ddof: Int = ddof_default): DataFrame<T> =
+    stdFor(skipNA, ddof, numberColumns())
+
+public fun <T> Grouped<T>.stdFor(
+    skipNA: Boolean = skipNA_default,
+    ddof: Int = ddof_default,
+    columns: ColumnsForAggregateSelector<T, Number?>,
+): DataFrame<T> = Aggregators.std(skipNA, ddof).aggregateFor(this, columns)
+
+public fun <T> Grouped<T>.stdFor(
+    vararg columns: String,
+    skipNA: Boolean = skipNA_default,
+    ddof: Int = ddof_default,
+): DataFrame<T> = stdFor(skipNA, ddof) { columns.toColumnsSetOf() }
+
+public fun <T, C : Number> Grouped<T>.stdFor(
+    vararg columns: ColumnReference<C?>,
+    skipNA: Boolean = skipNA_default,
+    ddof: Int = ddof_default,
+): DataFrame<T> = stdFor(skipNA, ddof) { columns.toColumnSet() }
+
+public fun <T, C : Number> Grouped<T>.stdFor(
+    vararg columns: KProperty<C?>,
+    skipNA: Boolean = skipNA_default,
+    ddof: Int = ddof_default,
+): DataFrame<T> = stdFor(skipNA, ddof) { columns.toColumnSet() }
+
+public fun <T> Grouped<T>.std(
+    name: String? = null,
+    skipNA: Boolean = skipNA_default,
+    ddof: Int = ddof_default,
+    columns: ColumnsSelector<T, Number?>,
+): DataFrame<T> = Aggregators.std(skipNA, ddof).aggregateAll(this, name, columns)
+
+public fun <T> Grouped<T>.std(
+    vararg columns: ColumnReference<Number?>,
+    name: String? = null,
+    skipNA: Boolean = skipNA_default,
+    ddof: Int = ddof_default,
+): DataFrame<T> = std(name, skipNA, ddof) { columns.toColumnSet() }
+
+public fun <T> Grouped<T>.std(
+    vararg columns: String,
+    name: String? = null,
+    skipNA: Boolean = skipNA_default,
+    ddof: Int = ddof_default,
+): DataFrame<T> = std(name, skipNA, ddof) { columns.toColumnsSetOf() }
+
+public fun <T> Grouped<T>.std(
+    vararg columns: KProperty<Number?>,
+    name: String? = null,
+    skipNA: Boolean = skipNA_default,
+    ddof: Int = ddof_default,
+): DataFrame<T> = std(name, skipNA, ddof) { columns.toColumnSet() }
+
+public inline fun <T, reified R : Number> Grouped<T>.stdOf(
+    name: String? = null,
+    skipNA: Boolean = skipNA_default,
+    ddof: Int = ddof_default,
+    crossinline expression: RowExpression<T, R?>,
+): DataFrame<T> = Aggregators.std(skipNA, ddof).aggregateOf(this, name, expression)
+
+// endregion
+
+// region Pivot
+
+public fun <T> Pivot<T>.std(
+    separate: Boolean = false,
+    skipNA: Boolean = skipNA_default,
+    ddof: Int = ddof_default,
+): DataRow<T> = stdFor(separate, skipNA, ddof, numberColumns())
+
+public fun <T, R : Number> Pivot<T>.stdFor(
+    separate: Boolean = false,
+    skipNA: Boolean = skipNA_default,
+    ddof: Int = ddof_default,
+    columns: ColumnsForAggregateSelector<T, R?>,
+): DataRow<T> = delegate { stdFor(separate, skipNA, ddof, columns) }
+
+public fun <T> Pivot<T>.stdFor(
+    vararg columns: String,
+    separate: Boolean = false,
+    skipNA: Boolean = skipNA_default,
+    ddof: Int = ddof_default,
+): DataRow<T> = stdFor(separate, skipNA, ddof) { columns.toColumnsSetOf() }
+
+public fun <T, C : Number> Pivot<T>.stdFor(
+    vararg columns: ColumnReference<C?>,
+    separate: Boolean = false,
+    skipNA: Boolean = skipNA_default,
+    ddof: Int = ddof_default,
+): DataRow<T> = stdFor(separate, skipNA, ddof) { columns.toColumnSet() }
+
+public fun <T, C : Number> Pivot<T>.stdFor(
+    vararg columns: KProperty<C?>,
+    separate: Boolean = false,
+    skipNA: Boolean = skipNA_default,
+    ddof: Int = ddof_default,
+): DataRow<T> = stdFor(separate, skipNA, ddof) { columns.toColumnSet() }
+
+public fun <T> Pivot<T>.std(
+    skipNA: Boolean = skipNA_default,
+    ddof: Int = ddof_default,
+    columns: ColumnsSelector<T, Number?>,
+): DataRow<T> = delegate { std(skipNA, ddof, columns) }
+
+public fun <T> Pivot<T>.std(
+    vararg columns: ColumnReference<Number?>,
+    skipNA: Boolean = skipNA_default,
+    ddof: Int = ddof_default,
+): DataRow<T> = std(skipNA, ddof) { columns.toColumnSet() }
+
+public fun <T> Pivot<T>.std(
+    vararg columns: String,
+    skipNA: Boolean = skipNA_default,
+    ddof: Int = ddof_default,
+): DataRow<T> = std(skipNA, ddof) { columns.toColumnsSetOf() }
+
+public fun <T> Pivot<T>.std(
+    vararg columns: KProperty<Number?>,
+    skipNA: Boolean = skipNA_default,
+    ddof: Int = ddof_default,
+): DataRow<T> = std(skipNA, ddof) { columns.toColumnSet() }
+
+public inline fun <reified T : Number> Pivot<T>.stdOf(
+    skipNA: Boolean = skipNA_default,
+    ddof: Int = ddof_default,
+    crossinline expression: RowExpression<T, T?>,
+): DataRow<T> = delegate { stdOf(skipNA, ddof, expression) }
+
+// endregion
+
+// region PivotGroupBy
+
+public fun <T> PivotGroupBy<T>.std(
+    separate: Boolean = false,
+    skipNA: Boolean = skipNA_default,
+    ddof: Int = ddof_default,
+): DataFrame<T> = stdFor(separate, skipNA, ddof, numberColumns())
+
+public fun <T, R : Number> PivotGroupBy<T>.stdFor(
+    separate: Boolean = false,
+    skipNA: Boolean = skipNA_default,
+    ddof: Int = ddof_default,
+    columns: ColumnsForAggregateSelector<T, R?>,
+): DataFrame<T> = Aggregators.std(skipNA, ddof).aggregateFor(this, separate, columns)
+
+public fun <T> PivotGroupBy<T>.stdFor(
+    vararg columns: String,
+    separate: Boolean = false,
+    skipNA: Boolean = skipNA_default,
+    ddof: Int = ddof_default,
+): DataFrame<T> = stdFor(separate, skipNA, ddof) { columns.toColumnsSetOf() }
+
+public fun <T, C : Number> PivotGroupBy<T>.stdFor(
+    vararg columns: ColumnReference<C?>,
+    separate: Boolean = false,
+    skipNA: Boolean = skipNA_default,
+    ddof: Int = ddof_default,
+): DataFrame<T> = stdFor(separate, skipNA, ddof) { columns.toColumnSet() }
+
+public fun <T, C : Number> PivotGroupBy<T>.stdFor(
+    vararg columns: KProperty<C?>,
+    separate: Boolean = false,
+    skipNA: Boolean = skipNA_default,
+    ddof: Int = ddof_default,
+): DataFrame<T> = stdFor(separate, skipNA, ddof) { columns.toColumnSet() }
+
+public fun <T> PivotGroupBy<T>.std(
+    skipNA: Boolean = skipNA_default,
+    ddof: Int = ddof_default,
+    columns: ColumnsSelector<T, Number?>,
+): DataFrame<T> = Aggregators.std(skipNA, ddof).aggregateAll(this, columns)
+
+public fun <T> PivotGroupBy<T>.std(
+    vararg columns: ColumnReference<Number?>,
+    skipNA: Boolean = skipNA_default,
+    ddof: Int = ddof_default,
+): DataFrame<T> = std(skipNA, ddof) { columns.toColumnSet() }
+
+public fun <T> PivotGroupBy<T>.std(
+    vararg columns: String,
+    skipNA: Boolean = skipNA_default,
+    ddof: Int = ddof_default,
+): DataFrame<T> = std(skipNA, ddof) { columns.toColumnsSetOf() }
+
+public fun <T> PivotGroupBy<T>.std(
+    vararg columns: KProperty<Number?>,
+    skipNA: Boolean = skipNA_default,
+    ddof: Int = ddof_default,
+): DataFrame<T> = std(skipNA, ddof) { columns.toColumnSet() }
+
+public inline fun <T, reified R : Number> PivotGroupBy<T>.stdOf(
+    skipNA: Boolean = skipNA_default,
+    ddof: Int = ddof_default,
+    crossinline expression: RowExpression<T, R?>,
+): DataFrame<T> = Aggregators.std(skipNA, ddof).aggregateOf(this, expression)
+
+// endregion
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/sum.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/sum.kt
new file mode 100644
index 000000000..be579ca16
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/sum.kt
@@ -0,0 +1,185 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import org.jetbrains.kotlinx.dataframe.AnyRow
+import org.jetbrains.kotlinx.dataframe.ColumnsSelector
+import org.jetbrains.kotlinx.dataframe.DataColumn
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.DataRow
+import org.jetbrains.kotlinx.dataframe.RowExpression
+import org.jetbrains.kotlinx.dataframe.aggregation.ColumnsForAggregateSelector
+import org.jetbrains.kotlinx.dataframe.columns.ColumnReference
+import org.jetbrains.kotlinx.dataframe.columns.toColumnSet
+import org.jetbrains.kotlinx.dataframe.columns.toColumnsSetOf
+import org.jetbrains.kotlinx.dataframe.columns.values
+import org.jetbrains.kotlinx.dataframe.impl.aggregation.aggregators.Aggregator
+import org.jetbrains.kotlinx.dataframe.impl.aggregation.aggregators.Aggregators
+import org.jetbrains.kotlinx.dataframe.impl.aggregation.aggregators.cast
+import org.jetbrains.kotlinx.dataframe.impl.aggregation.modes.aggregateAll
+import org.jetbrains.kotlinx.dataframe.impl.aggregation.modes.aggregateFor
+import org.jetbrains.kotlinx.dataframe.impl.aggregation.modes.aggregateOf
+import org.jetbrains.kotlinx.dataframe.impl.aggregation.modes.of
+import org.jetbrains.kotlinx.dataframe.impl.aggregation.numberColumns
+import org.jetbrains.kotlinx.dataframe.impl.columns.toNumberColumns
+import org.jetbrains.kotlinx.dataframe.impl.zero
+import org.jetbrains.kotlinx.dataframe.math.sum
+import org.jetbrains.kotlinx.dataframe.math.sumOf
+import kotlin.reflect.KProperty
+import kotlin.reflect.typeOf
+
+// region DataColumn
+
+@JvmName("sumT")
+public fun <T : Number> DataColumn<T>.sum(): T = values.sum(type())
+
+@JvmName("sumTNullable")
+public fun <T : Number> DataColumn<T?>.sum(): T = values.sum(type())
+
+public inline fun <T, reified R : Number> DataColumn<T>.sumOf(crossinline expression: (T) -> R): R? =
+    (Aggregators.sum as Aggregator<*, *>).cast<R>().of(this, expression)
+
+// endregion
+
+// region DataRow
+
+public fun AnyRow.rowSum(): Number = Aggregators.sum.aggregateMixed(values().filterIsInstance<Number>()) ?: 0
+
+public inline fun <reified T : Number> AnyRow.rowSumOf(): T = values().filterIsInstance<T>().sum(typeOf<T>())
+
+// endregion
+
+// region DataFrame
+
+public fun <T> DataFrame<T>.sum(): DataRow<T> = sumFor(numberColumns())
+
+public fun <T, C : Number> DataFrame<T>.sumFor(columns: ColumnsForAggregateSelector<T, C?>): DataRow<T> =
+    Aggregators.sum.aggregateFor(this, columns)
+
+public fun <T> DataFrame<T>.sumFor(vararg columns: String): DataRow<T> = sumFor { columns.toColumnsSetOf() }
+
+public fun <T, C : Number> DataFrame<T>.sumFor(vararg columns: ColumnReference<C?>): DataRow<T> =
+    sumFor { columns.toColumnSet() }
+
+public fun <T, C : Number> DataFrame<T>.sumFor(vararg columns: KProperty<C?>): DataRow<T> =
+    sumFor { columns.toColumnSet() }
+
+public inline fun <T, reified C : Number> DataFrame<T>.sum(noinline columns: ColumnsSelector<T, C?>): C =
+    (Aggregators.sum.aggregateAll(this, columns) as C?) ?: C::class.zero()
+
+public inline fun <T, reified C : Number> DataFrame<T>.sum(vararg columns: ColumnReference<C?>): C =
+    sum { columns.toColumnSet() }
+
+public fun <T> DataFrame<T>.sum(vararg columns: String): Number = sum { columns.toColumnsSetOf() }
+
+public inline fun <T, reified C : Number> DataFrame<T>.sum(vararg columns: KProperty<C?>): C =
+    sum { columns.toColumnSet() }
+
+public inline fun <T, reified C : Number?> DataFrame<T>.sumOf(crossinline expression: RowExpression<T, C>): C =
+    rows().sumOf(typeOf<C>()) { expression(it, it) }
+
+// endregion
+
+// region GroupBy
+
+public fun <T> Grouped<T>.sum(): DataFrame<T> = sumFor(numberColumns())
+
+public fun <T, C : Number> Grouped<T>.sumFor(columns: ColumnsForAggregateSelector<T, C?>): DataFrame<T> =
+    Aggregators.sum.aggregateFor(this, columns)
+
+public fun <T> Grouped<T>.sumFor(vararg columns: String): DataFrame<T> = sumFor { columns.toNumberColumns() }
+
+public fun <T, C : Number> Grouped<T>.sumFor(vararg columns: ColumnReference<C?>): DataFrame<T> =
+    sumFor { columns.toColumnSet() }
+
+public fun <T, C : Number> Grouped<T>.sumFor(vararg columns: KProperty<C?>): DataFrame<T> =
+    sumFor { columns.toColumnSet() }
+
+public fun <T, C : Number> Grouped<T>.sum(name: String? = null, columns: ColumnsSelector<T, C?>): DataFrame<T> =
+    Aggregators.sum.aggregateAll(this, name, columns)
+
+public fun <T> Grouped<T>.sum(vararg columns: String, name: String? = null): DataFrame<T> =
+    sum(name) { columns.toNumberColumns() }
+
+public fun <T, C : Number> Grouped<T>.sum(vararg columns: ColumnReference<C?>, name: String? = null): DataFrame<T> =
+    sum(name) { columns.toColumnSet() }
+
+public fun <T, C : Number> Grouped<T>.sum(vararg columns: KProperty<C?>, name: String? = null): DataFrame<T> =
+    sum(name) { columns.toColumnSet() }
+
+public inline fun <T, reified R : Number> Grouped<T>.sumOf(
+    resultName: String? = null,
+    crossinline expression: RowExpression<T, R?>,
+): DataFrame<T> = Aggregators.sum.aggregateOf(this, resultName, expression)
+
+// endregion
+
+// region Pivot
+
+public fun <T> Pivot<T>.sum(separate: Boolean = false): DataRow<T> = sumFor(separate, numberColumns())
+
+public fun <T, R : Number> Pivot<T>.sumFor(
+    separate: Boolean = false,
+    columns: ColumnsForAggregateSelector<T, R?>,
+): DataRow<T> = delegate { sumFor(separate, columns) }
+
+public fun <T> Pivot<T>.sumFor(vararg columns: String, separate: Boolean = false): DataRow<T> =
+    sumFor(separate) { columns.toNumberColumns() }
+
+public fun <T, C : Number> Pivot<T>.sumFor(
+    vararg columns: ColumnReference<C?>,
+    separate: Boolean = false,
+): DataRow<T> = sumFor(separate) { columns.toColumnSet() }
+
+public fun <T, C : Number> Pivot<T>.sumFor(vararg columns: KProperty<C?>, separate: Boolean = false): DataRow<T> =
+    sumFor(separate) { columns.toColumnSet() }
+
+public fun <T, C : Number> Pivot<T>.sum(columns: ColumnsSelector<T, C?>): DataRow<T> = delegate { sum(columns) }
+
+public fun <T> Pivot<T>.sum(vararg columns: String): DataRow<T> = sum { columns.toNumberColumns() }
+
+public fun <T, C : Number> Pivot<T>.sum(vararg columns: ColumnReference<C?>): DataRow<T> = sum { columns.toColumnSet() }
+
+public fun <T, C : Number> Pivot<T>.sum(vararg columns: KProperty<C?>): DataRow<T> = sum { columns.toColumnSet() }
+
+public inline fun <T, reified R : Number> Pivot<T>.sumOf(crossinline expression: RowExpression<T, R>): DataRow<T> =
+    delegate { sumOf(expression) }
+
+// endregion
+
+// region PivotGroupBy
+
+public fun <T> PivotGroupBy<T>.sum(separate: Boolean = false): DataFrame<T> = sumFor(separate, numberColumns())
+
+public fun <T, R : Number> PivotGroupBy<T>.sumFor(
+    separate: Boolean = false,
+    columns: ColumnsForAggregateSelector<T, R?>,
+): DataFrame<T> = Aggregators.sum.aggregateFor(this, separate, columns)
+
+public fun <T> PivotGroupBy<T>.sumFor(vararg columns: String, separate: Boolean = false): DataFrame<T> =
+    sumFor(separate) { columns.toNumberColumns() }
+
+public fun <T, C : Number> PivotGroupBy<T>.sumFor(
+    vararg columns: ColumnReference<C?>,
+    separate: Boolean = false,
+): DataFrame<T> = sumFor(separate) { columns.toColumnSet() }
+
+public fun <T, C : Number> PivotGroupBy<T>.sumFor(
+    vararg columns: KProperty<C?>,
+    separate: Boolean = false,
+): DataFrame<T> = sumFor(separate) { columns.toColumnSet() }
+
+public fun <T, C : Number> PivotGroupBy<T>.sum(columns: ColumnsSelector<T, C?>): DataFrame<T> =
+    Aggregators.sum.aggregateAll(this, columns)
+
+public fun <T> PivotGroupBy<T>.sum(vararg columns: String): DataFrame<T> = sum { columns.toNumberColumns() }
+
+public fun <T, C : Number> PivotGroupBy<T>.sum(vararg columns: ColumnReference<C?>): DataFrame<T> =
+    sum { columns.toColumnSet() }
+
+public fun <T, C : Number> PivotGroupBy<T>.sum(vararg columns: KProperty<C?>): DataFrame<T> =
+    sum { columns.toColumnSet() }
+
+public inline fun <T, reified R : Number> PivotGroupBy<T>.sumOf(
+    crossinline expression: RowExpression<T, R>,
+): DataFrame<T> = Aggregators.sum.aggregateOf(this, expression)
+
+// endregion
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/tail.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/tail.kt
new file mode 100644
index 000000000..1228924f4
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/tail.kt
@@ -0,0 +1,9 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import org.jetbrains.kotlinx.dataframe.DataFrame
+
+// region DataFrame
+
+public fun <T> DataFrame<T>.tail(numRows: Int = 5): DataFrame<T> = takeLast(numRows)
+
+// endregion
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/take.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/take.kt
new file mode 100644
index 000000000..2c4d9430e
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/take.kt
@@ -0,0 +1,1095 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import org.jetbrains.kotlinx.dataframe.ColumnFilter
+import org.jetbrains.kotlinx.dataframe.DataColumn
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.DataRow
+import org.jetbrains.kotlinx.dataframe.RowFilter
+import org.jetbrains.kotlinx.dataframe.columns.ColumnPath
+import org.jetbrains.kotlinx.dataframe.columns.ColumnSet
+import org.jetbrains.kotlinx.dataframe.columns.ColumnWithPath
+import org.jetbrains.kotlinx.dataframe.columns.SingleColumn
+import org.jetbrains.kotlinx.dataframe.columns.size
+import org.jetbrains.kotlinx.dataframe.impl.columns.transform
+import org.jetbrains.kotlinx.dataframe.impl.columns.transformSingle
+import org.jetbrains.kotlinx.dataframe.index
+import org.jetbrains.kotlinx.dataframe.nrow
+import kotlin.reflect.KProperty
+
+// region DataColumn
+
+public fun <T> DataColumn<T>.take(n: Int): DataColumn<T> =
+    when {
+        n == 0 -> get(emptyList())
+        n >= size -> this
+        else -> get(0 until n)
+    }
+
+public fun <T> DataColumn<T>.takeLast(n: Int = 1): DataColumn<T> = drop(size - n)
+
+// endregion
+
+// region DataFrame
+
+/**
+ * Returns a DataFrame containing first [n] rows.
+ *
+ * @throws IllegalArgumentException if [n] is negative.
+ */
+public fun <T> DataFrame<T>.take(n: Int): DataFrame<T> {
+    require(n >= 0) { "Requested rows count $n is less than zero." }
+    return getRows(0 until n.coerceAtMost(nrow))
+}
+
+/**
+ * Returns a DataFrame containing last [n] rows.
+ *
+ * @throws IllegalArgumentException if [n] is negative.
+ */
+public fun <T> DataFrame<T>.takeLast(n: Int = 1): DataFrame<T> {
+    require(n >= 0) { "Requested rows count $n is less than zero." }
+    return drop((nrow - n).coerceAtLeast(0))
+}
+
+/**
+ * Returns a DataFrame containing first rows that satisfy the given [predicate].
+ */
+public fun <T> DataFrame<T>.takeWhile(predicate: RowFilter<T>): DataFrame<T> =
+    firstOrNull { !predicate(it, it) }?.let { take(it.index) } ?: this
+
+// endregion
+
+// region ColumnsSelectionDsl
+
+/**
+ * ## Take [Columns Selection DSL][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl]
+ *
+ * See [Grammar] for all functions in this interface.
+ */
+public interface TakeColumnsSelectionDsl {
+
+    /**
+     * ## Take (Last) (Cols) (While) Grammar
+     *
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * [(What is this notation?)][org.jetbrains.kotlinx.dataframe.documentation.DslGrammar]
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  ### Definitions:
+     *  `columnSet: `[`ColumnSet`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]`<*>`
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  `columnGroup: `[`SingleColumn`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]`<`[`DataRow`][org.jetbrains.kotlinx.dataframe.DataRow]`<*>> | `[`String`][String]`  |  `[`KProperty`][kotlin.reflect.KProperty]`<* | `[`DataRow`][org.jetbrains.kotlinx.dataframe.DataRow]`<*>> | `[`ColumnPath`][org.jetbrains.kotlinx.dataframe.columns.ColumnPath]
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  `condition: `[`ColumnFilter`][org.jetbrains.kotlinx.dataframe.ColumnFilter]
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  `number: `[`Int`][Int]
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  ### What can be called directly in the [Columns Selection DSL][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl]:
+     *
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  [**`take`**][ColumnsSelectionDsl.take]`(`[**`Last`**][ColumnsSelectionDsl.takeLast]`)`**`(`**[`number`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.NumberDef]**`)`**
+     *
+     *  `| `[**`take`**][ColumnsSelectionDsl.takeWhile]`(`[**`Last`**][ColumnsSelectionDsl.takeLastWhile]`)`[**`While`**][ColumnsSelectionDsl.takeWhile]**`  {  `**[`condition`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ConditionDef]**` }`**
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  ### What can be called on a [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]:
+     *
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  [`columnSet`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ColumnSetDef]
+     *
+     *  &nbsp;&nbsp;&nbsp;&nbsp;__`.`__[**`take`**][ColumnsSelectionDsl.take]`(`[**`Last`**][ColumnSet.takeLast]`)`**`(`**[`number`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.NumberDef]**`)`**
+     *
+     *  &nbsp;&nbsp;&nbsp;&nbsp;`| `__`.`__[**`take`**][ColumnsSelectionDsl.takeWhile]`(`[**`Last`**][ColumnsSelectionDsl.takeLastWhile]`)`[**`While`**][ColumnsSelectionDsl.takeWhile]**`  {  `**[`condition`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ConditionDef]**` }`**
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  ### What can be called on a [Column Group (reference)][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ColumnGroupDef]:
+     *
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  [`columnGroup`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ColumnGroupDef]
+     *
+     *  &nbsp;&nbsp;&nbsp;&nbsp;__`.`__[**`take`**][ColumnsSelectionDsl.takeCols]`(`[**`Last`**][ColumnsSelectionDsl.takeLastCols]`)`[**`Cols`**][ColumnsSelectionDsl.takeCols]**`(`**[`number`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.NumberDef]**`)`**
+     *
+     *  &nbsp;&nbsp;&nbsp;&nbsp;`| `__`.`__[**`take`**][ColumnsSelectionDsl.takeColsWhile]`(`[**`Last`**][ColumnsSelectionDsl.takeLastColsWhile]`)`[**`ColsWhile`**][ColumnsSelectionDsl.takeColsWhile]**`  {  `**[`condition`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ConditionDef]**` }`**
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     */
+    public interface Grammar {
+
+        /** [**`take`**][ColumnsSelectionDsl.take]`(`[**`Last`**][ColumnsSelectionDsl.takeLast]`)` */
+        public interface PlainDslName
+
+        /** __`.`__[**`take`**][ColumnsSelectionDsl.take]`(`[**`Last`**][ColumnSet.takeLast]`)` */
+        public interface ColumnSetName
+
+        /** __`.`__[**`take`**][ColumnsSelectionDsl.takeCols]`(`[**`Last`**][ColumnsSelectionDsl.takeLastCols]`)`[**`Cols`**][ColumnsSelectionDsl.takeCols] */
+        public interface ColumnGroupName
+
+        /** [**`take`**][ColumnsSelectionDsl.takeWhile]`(`[**`Last`**][ColumnsSelectionDsl.takeLastWhile]`)`[**`While`**][ColumnsSelectionDsl.takeWhile] */
+        public interface PlainDslWhileName
+
+        /** __`.`__[**`take`**][ColumnsSelectionDsl.takeWhile]`(`[**`Last`**][ColumnsSelectionDsl.takeLastWhile]`)`[**`While`**][ColumnsSelectionDsl.takeWhile] */
+        public interface ColumnSetWhileName
+
+        /** __`.`__[**`take`**][ColumnsSelectionDsl.takeColsWhile]`(`[**`Last`**][ColumnsSelectionDsl.takeLastColsWhile]`)`[**`ColsWhile`**][ColumnsSelectionDsl.takeColsWhile] */
+        public interface ColumnGroupWhileName
+    }
+
+    // region take
+
+    /**
+     * ## Take (Cols)
+     * This takes the first [n] columns from [this] collecting
+     * the result into a [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet].
+     *
+     * This function operates solely on columns at the top-level.
+     *
+     * Any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi] can be used as receiver for these functions.
+     *
+     * NOTE: To avoid ambiguity, `take` is called `takeCols` when called on
+     * a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * ### Check out: [Grammar]
+     *
+     * #### Examples:
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { `[cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]` { "my" `[in][String.contains]` it.`[name][org.jetbrains.kotlinx.dataframe.DataColumn.name]` }.`[take][ColumnSet.take]`(5) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { `[take][ColumnsSelectionDsl.take]`(1) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[takeCols][SingleColumn.takeCols]`(2) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "myColumnGroup".`[takeCols][String.takeCols]`(3) }`
+     *
+     * #### Examples for this overload:
+     *
+     *
+     *
+     * @param [n] The number of columns to take.
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing the first [n] columns.
+     */
+    private interface CommonTakeFirstDocs
+
+    /**
+     * ## Take (Cols)
+     * This takes the first [n] columns from [this] collecting
+     * the result into a [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet].
+     *
+     * This function operates solely on columns at the top-level.
+     *
+     * Any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi] can be used as receiver for these functions.
+     *
+     * NOTE: To avoid ambiguity, `take` is called `takeCols` when called on
+     * a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * ### Check out: [Grammar]
+     *
+     * #### Examples:
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { `[cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]` { "my" `[in][String.contains]` it.`[name][org.jetbrains.kotlinx.dataframe.DataColumn.name]` }.`[take][ColumnSet.take]`(5) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { `[take][ColumnsSelectionDsl.take]`(1) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[takeCols][SingleColumn.takeCols]`(2) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "myColumnGroup".`[takeCols][String.takeCols]`(3) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][DataFrame.select]`  {  `[colsOf][SingleColumn.colsOf]`<`[String][String]`>().`[take][ColumnSet.take]`(2) }`
+     *
+     * `df.`[select][DataFrame.select]`  {  `[cols][ColumnsSelectionDsl.cols]` { .. }.`[take][ColumnSet.take]`(2) }`
+     *
+     * @param [n] The number of columns to take.
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing the first [n] columns.
+     */
+    public fun <C> ColumnSet<C>.take(n: Int): ColumnSet<C> = transform { it.take(n) }
+
+    /**
+     * ## Take (Cols)
+     * This takes the first [n] columns from [this] collecting
+     * the result into a [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet].
+     *
+     * This function operates solely on columns at the top-level.
+     *
+     * Any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi] can be used as receiver for these functions.
+     *
+     * NOTE: To avoid ambiguity, `take` is called `takeCols` when called on
+     * a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * ### Check out: [Grammar]
+     *
+     * #### Examples:
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { `[cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]` { "my" `[in][String.contains]` it.`[name][org.jetbrains.kotlinx.dataframe.DataColumn.name]` }.`[take][ColumnSet.take]`(5) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { `[take][ColumnsSelectionDsl.take]`(1) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[takeCols][SingleColumn.takeCols]`(2) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "myColumnGroup".`[takeCols][String.takeCols]`(3) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][DataFrame.select]`  {  `[take][ColumnsSelectionDsl.take]`(5) }`
+     *
+     * @param [n] The number of columns to take.
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing the first [n] columns.
+     */
+    public fun ColumnsSelectionDsl<*>.take(n: Int): ColumnSet<*> = this.asSingleColumn().takeCols(n)
+
+    /**
+     * ## Take (Cols)
+     * This takes the first [n] columns from [this] collecting
+     * the result into a [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet].
+     *
+     * This function operates solely on columns at the top-level.
+     *
+     * Any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi] can be used as receiver for these functions.
+     *
+     * NOTE: To avoid ambiguity, `take` is called `takeCols` when called on
+     * a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * ### Check out: [Grammar]
+     *
+     * #### Examples:
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { `[cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]` { "my" `[in][String.contains]` it.`[name][org.jetbrains.kotlinx.dataframe.DataColumn.name]` }.`[take][ColumnSet.take]`(5) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { `[take][ColumnsSelectionDsl.take]`(1) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[takeCols][SingleColumn.takeCols]`(2) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "myColumnGroup".`[takeCols][String.takeCols]`(3) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][DataFrame.select]` { myColumnGroup.`[takeCols][SingleColumn.takeCols]`(1) }`
+     *
+     * @param [n] The number of columns to take.
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing the first [n] columns.
+     */
+    public fun SingleColumn<DataRow<*>>.takeCols(n: Int): ColumnSet<*> =
+        this.ensureIsColumnGroup().transformSingle { it.cols().take(n) }
+
+    /**
+     * ## Take (Cols)
+     * This takes the first [n] columns from [this] collecting
+     * the result into a [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet].
+     *
+     * This function operates solely on columns at the top-level.
+     *
+     * Any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi] can be used as receiver for these functions.
+     *
+     * NOTE: To avoid ambiguity, `take` is called `takeCols` when called on
+     * a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * ### Check out: [Grammar]
+     *
+     * #### Examples:
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { `[cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]` { "my" `[in][String.contains]` it.`[name][org.jetbrains.kotlinx.dataframe.DataColumn.name]` }.`[take][ColumnSet.take]`(5) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { `[take][ColumnsSelectionDsl.take]`(1) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[takeCols][SingleColumn.takeCols]`(2) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "myColumnGroup".`[takeCols][String.takeCols]`(3) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][DataFrame.select]` { "myColumnGroup".`[takeCols][String.takeCols]`(1) }`
+     *
+     * @param [n] The number of columns to take.
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing the first [n] columns.
+     */
+    public fun String.takeCols(n: Int): ColumnSet<*> = columnGroup(this).takeCols(n)
+
+    /**
+     * ## Take (Cols)
+     * This takes the first [n] columns from [this] collecting
+     * the result into a [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet].
+     *
+     * This function operates solely on columns at the top-level.
+     *
+     * Any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi] can be used as receiver for these functions.
+     *
+     * NOTE: To avoid ambiguity, `take` is called `takeCols` when called on
+     * a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * ### Check out: [Grammar]
+     *
+     * #### Examples:
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { `[cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]` { "my" `[in][String.contains]` it.`[name][org.jetbrains.kotlinx.dataframe.DataColumn.name]` }.`[take][ColumnSet.take]`(5) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { `[take][ColumnsSelectionDsl.take]`(1) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[takeCols][SingleColumn.takeCols]`(2) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "myColumnGroup".`[takeCols][String.takeCols]`(3) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][DataFrame.select]` { Type::myColumnGroup.`[takeCols][SingleColumn.takeCols]`(1) }`
+     *
+     * `df.`[select][DataFrame.select]` { DataSchemaType::myColumnGroup.`[takeCols][KProperty.takeCols]`(1) }`
+     *
+     * @param [n] The number of columns to take.
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing the first [n] columns.
+     */
+    public fun KProperty<*>.takeCols(n: Int): ColumnSet<*> = columnGroup(this).takeCols(n)
+
+    /**
+     * ## Take (Cols)
+     * This takes the first [n] columns from [this] collecting
+     * the result into a [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet].
+     *
+     * This function operates solely on columns at the top-level.
+     *
+     * Any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi] can be used as receiver for these functions.
+     *
+     * NOTE: To avoid ambiguity, `take` is called `takeCols` when called on
+     * a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * ### Check out: [Grammar]
+     *
+     * #### Examples:
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { `[cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]` { "my" `[in][String.contains]` it.`[name][org.jetbrains.kotlinx.dataframe.DataColumn.name]` }.`[take][ColumnSet.take]`(5) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { `[take][ColumnsSelectionDsl.take]`(1) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[takeCols][SingleColumn.takeCols]`(2) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "myColumnGroup".`[takeCols][String.takeCols]`(3) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][DataFrame.select]` { "pathTo"["myColumnGroup"].`[takeCols][ColumnPath.takeCols]`(1) }`
+     *
+     * @param [n] The number of columns to take.
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing the first [n] columns.
+     */
+    public fun ColumnPath.takeCols(n: Int): ColumnSet<*> = columnGroup(this).takeCols(n)
+
+    // endregion
+
+    // region takeLast
+
+    /**
+     * ## Take Last (Cols)
+     * This takes the last [n] columns from [this] collecting
+     * the result into a [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet].
+     *
+     * This function operates solely on columns at the top-level.
+     *
+     * Any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi] can be used as receiver for these functions.
+     *
+     * NOTE: To avoid ambiguity, `takeLast` is called `takeLastCols` when called on
+     * a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * ### Check out: [Grammar]
+     *
+     * #### Examples:
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { `[cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]` { "my" `[in][String.contains]` it.`[name][org.jetbrains.kotlinx.dataframe.DataColumn.name]` }.`[takeLast][ColumnSet.takeLast]`(5) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { `[takeLast][ColumnsSelectionDsl.takeLast]`(1) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[takeLastCols][SingleColumn.takeLastCols]`(2) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "myColumnGroup".`[takeLastCols][String.takeLastCols]`(3) }`
+     *
+     * #### Examples for this overload:
+     *
+     *
+     *
+     * @param [n] The number of columns to take.
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing the last [n] columns.
+     */
+    private interface CommonTakeLastDocs
+
+    /**
+     * ## Take Last (Cols)
+     * This takes the last [n] columns from [this] collecting
+     * the result into a [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet].
+     *
+     * This function operates solely on columns at the top-level.
+     *
+     * Any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi] can be used as receiver for these functions.
+     *
+     * NOTE: To avoid ambiguity, `takeLast` is called `takeLastCols` when called on
+     * a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * ### Check out: [Grammar]
+     *
+     * #### Examples:
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { `[cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]` { "my" `[in][String.contains]` it.`[name][org.jetbrains.kotlinx.dataframe.DataColumn.name]` }.`[takeLast][ColumnSet.takeLast]`(5) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { `[takeLast][ColumnsSelectionDsl.takeLast]`(1) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[takeLastCols][SingleColumn.takeLastCols]`(2) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "myColumnGroup".`[takeLastCols][String.takeLastCols]`(3) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][DataFrame.select]`  {  `[colsOf][SingleColumn.colsOf]`<`[String][String]`>().`[takeLast][ColumnSet.takeLast]`(2) }`
+     *
+     * `df.`[select][DataFrame.select]`  {  `[cols][ColumnsSelectionDsl.cols]` { .. }.`[takeLast][ColumnSet.takeLast]`(2) }`
+     *
+     * @param [n] The number of columns to take.
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing the last [n] columns.
+     */
+    public fun <C> ColumnSet<C>.takeLast(n: Int = 1): ColumnSet<C> = transform { it.takeLast(n) }
+
+    /**
+     * ## Take Last (Cols)
+     * This takes the last [n] columns from [this] collecting
+     * the result into a [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet].
+     *
+     * This function operates solely on columns at the top-level.
+     *
+     * Any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi] can be used as receiver for these functions.
+     *
+     * NOTE: To avoid ambiguity, `takeLast` is called `takeLastCols` when called on
+     * a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * ### Check out: [Grammar]
+     *
+     * #### Examples:
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { `[cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]` { "my" `[in][String.contains]` it.`[name][org.jetbrains.kotlinx.dataframe.DataColumn.name]` }.`[takeLast][ColumnSet.takeLast]`(5) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { `[takeLast][ColumnsSelectionDsl.takeLast]`(1) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[takeLastCols][SingleColumn.takeLastCols]`(2) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "myColumnGroup".`[takeLastCols][String.takeLastCols]`(3) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][DataFrame.select]`  {  `[takeLast][ColumnsSelectionDsl.takeLast]`(5) }`
+     *
+     * @param [n] The number of columns to take.
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing the last [n] columns.
+     */
+    public fun ColumnsSelectionDsl<*>.takeLast(n: Int = 1): ColumnSet<*> = asSingleColumn().takeLastCols(n)
+
+    /**
+     * ## Take Last (Cols)
+     * This takes the last [n] columns from [this] collecting
+     * the result into a [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet].
+     *
+     * This function operates solely on columns at the top-level.
+     *
+     * Any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi] can be used as receiver for these functions.
+     *
+     * NOTE: To avoid ambiguity, `takeLast` is called `takeLastCols` when called on
+     * a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * ### Check out: [Grammar]
+     *
+     * #### Examples:
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { `[cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]` { "my" `[in][String.contains]` it.`[name][org.jetbrains.kotlinx.dataframe.DataColumn.name]` }.`[takeLast][ColumnSet.takeLast]`(5) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { `[takeLast][ColumnsSelectionDsl.takeLast]`(1) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[takeLastCols][SingleColumn.takeLastCols]`(2) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "myColumnGroup".`[takeLastCols][String.takeLastCols]`(3) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][DataFrame.select]` { myColumnGroup.`[takeLast][SingleColumn.takeLastCols]`(1) }`
+     *
+     * @param [n] The number of columns to take.
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing the last [n] columns.
+     */
+    public fun SingleColumn<DataRow<*>>.takeLastCols(n: Int): ColumnSet<*> =
+        this.ensureIsColumnGroup().transformSingle { it.cols().takeLast(n) }
+
+    /**
+     * ## Take Last (Cols)
+     * This takes the last [n] columns from [this] collecting
+     * the result into a [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet].
+     *
+     * This function operates solely on columns at the top-level.
+     *
+     * Any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi] can be used as receiver for these functions.
+     *
+     * NOTE: To avoid ambiguity, `takeLast` is called `takeLastCols` when called on
+     * a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * ### Check out: [Grammar]
+     *
+     * #### Examples:
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { `[cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]` { "my" `[in][String.contains]` it.`[name][org.jetbrains.kotlinx.dataframe.DataColumn.name]` }.`[takeLast][ColumnSet.takeLast]`(5) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { `[takeLast][ColumnsSelectionDsl.takeLast]`(1) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[takeLastCols][SingleColumn.takeLastCols]`(2) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "myColumnGroup".`[takeLastCols][String.takeLastCols]`(3) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][DataFrame.select]` { "myColumnGroup".`[takeLastCols][String.takeLastCols]`(1) }`
+     *
+     * @param [n] The number of columns to take.
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing the last [n] columns.
+     */
+    public fun String.takeLastCols(n: Int): ColumnSet<*> = columnGroup(this).takeLastCols(n)
+
+    /**
+     * ## Take Last (Cols)
+     * This takes the last [n] columns from [this] collecting
+     * the result into a [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet].
+     *
+     * This function operates solely on columns at the top-level.
+     *
+     * Any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi] can be used as receiver for these functions.
+     *
+     * NOTE: To avoid ambiguity, `takeLast` is called `takeLastCols` when called on
+     * a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * ### Check out: [Grammar]
+     *
+     * #### Examples:
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { `[cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]` { "my" `[in][String.contains]` it.`[name][org.jetbrains.kotlinx.dataframe.DataColumn.name]` }.`[takeLast][ColumnSet.takeLast]`(5) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { `[takeLast][ColumnsSelectionDsl.takeLast]`(1) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[takeLastCols][SingleColumn.takeLastCols]`(2) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "myColumnGroup".`[takeLastCols][String.takeLastCols]`(3) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][DataFrame.select]` { Type::myColumnGroup.`[takeLastCols][SingleColumn.takeLastCols]`(1) }`
+     *
+     * `df.`[select][DataFrame.select]` { DataSchemaType::myColumnGroup.`[takeLastCols][KProperty.takeLastCols]`(1) }`
+     *
+     * @param [n] The number of columns to take.
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing the last [n] columns.
+     */
+    public fun KProperty<*>.takeLastCols(n: Int): ColumnSet<*> = columnGroup(this).takeLastCols(n)
+
+    /**
+     * ## Take Last (Cols)
+     * This takes the last [n] columns from [this] collecting
+     * the result into a [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet].
+     *
+     * This function operates solely on columns at the top-level.
+     *
+     * Any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi] can be used as receiver for these functions.
+     *
+     * NOTE: To avoid ambiguity, `takeLast` is called `takeLastCols` when called on
+     * a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * ### Check out: [Grammar]
+     *
+     * #### Examples:
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { `[cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]` { "my" `[in][String.contains]` it.`[name][org.jetbrains.kotlinx.dataframe.DataColumn.name]` }.`[takeLast][ColumnSet.takeLast]`(5) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { `[takeLast][ColumnsSelectionDsl.takeLast]`(1) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[takeLastCols][SingleColumn.takeLastCols]`(2) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "myColumnGroup".`[takeLastCols][String.takeLastCols]`(3) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][DataFrame.select]` { "pathTo"["myColumnGroup"].`[takeLastCols][ColumnPath.takeLastCols]`(1) }`
+     *
+     * @param [n] The number of columns to take.
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing the last [n] columns.
+     */
+    public fun ColumnPath.takeLastCols(n: Int): ColumnSet<*> = columnGroup(this).takeLastCols(n)
+
+    // endregion
+
+    // region takeWhile
+
+    /**
+     * ## Take (Cols) While
+     * This function takes the first columns from [this] adhering to the
+     * given [predicate] collecting the result into a [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet].
+     *
+     * This function operates solely on columns at the top-level.
+     *
+     * Any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi] can be used as receiver for these functions.
+     *
+     * NOTE: To avoid ambiguity, `takeWhile` is called
+     * `takeColsWhile` when called on a [String] or [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath] resembling
+     * a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * ### Check out: [Usage]
+     *
+     * #### Examples:
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { `[`cols`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]` { "my" `[`in`][String.contains]` it.`[`name`][org.jetbrains.kotlinx.dataframe.DataColumn.name]` }.`[`takeWhile`][ColumnSet.takeWhile]` { "my" `[`in`][String.contains]` it.`[`name`][org.jetbrains.kotlinx.dataframe.DataColumn.name]` } }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[`takeWhile`][SingleColumn.takeColsWhile]` { it.`[`any`][org.jetbrains.kotlinx.dataframe.DataColumn.any]` { it == "Alice" } } }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "myColumnGroup".`[`takeColsWhile`][String.takeColsWhile]` { it.`[`kind`][org.jetbrains.kotlinx.dataframe.DataColumn.kind]`() == `[`ColumnKind.Value`][org.jetbrains.kotlinx.dataframe.columns.ColumnKind.Value]` } }`
+     *
+     * #### Examples for this overload:
+     *
+     *
+     *
+     * @param [predicate] The [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter] to control which columns to take.
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing the first columns adhering to the [predicate].
+     */
+    private interface CommonTakeFirstWhileDocs
+
+    /**
+     * ## Take (Cols) While
+     * This function takes the first columns from [this] adhering to the
+     * given [predicate] collecting the result into a [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet].
+     *
+     * This function operates solely on columns at the top-level.
+     *
+     * Any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi] can be used as receiver for these functions.
+     *
+     * NOTE: To avoid ambiguity, `takeWhile` is called
+     * `takeColsWhile` when called on a [String] or [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath] resembling
+     * a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * ### Check out: [Usage]
+     *
+     * #### Examples:
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { `[`cols`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]` { "my" `[`in`][String.contains]` it.`[`name`][org.jetbrains.kotlinx.dataframe.DataColumn.name]` }.`[`takeWhile`][ColumnSet.takeWhile]` { "my" `[`in`][String.contains]` it.`[`name`][org.jetbrains.kotlinx.dataframe.DataColumn.name]` } }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[`takeWhile`][SingleColumn.takeColsWhile]` { it.`[`any`][org.jetbrains.kotlinx.dataframe.DataColumn.any]` { it == "Alice" } } }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "myColumnGroup".`[`takeColsWhile`][String.takeColsWhile]` { it.`[`kind`][org.jetbrains.kotlinx.dataframe.DataColumn.kind]`() == `[`ColumnKind.Value`][org.jetbrains.kotlinx.dataframe.columns.ColumnKind.Value]` } }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][DataFrame.select]`  {  `[colsOf][SingleColumn.colsOf]`<`[String][String]`>().`[takeWhile][ColumnSet.takeWhile]` { it.`[any][ColumnWithPath.any]` { it == "Alice" } } }`
+     *
+     * `df.`[select][DataFrame.select]`  {  `[cols][ColumnsSelectionDsl.cols]` { .. }.`[takeWhile][ColumnSet.takeWhile]` { it.`[name][ColumnWithPath.name]`.`[startsWith][String.startsWith]`("my") } }`
+     *
+     * @param [predicate] The [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter] to control which columns to take.
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing the first columns adhering to the [predicate].
+     */
+    public fun <C> ColumnSet<C>.takeWhile(predicate: ColumnFilter<C>): ColumnSet<C> =
+        transform { it.takeWhile(predicate) }
+
+    /**
+     * ## Take (Cols) While
+     * This function takes the first columns from [this] adhering to the
+     * given [predicate] collecting the result into a [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet].
+     *
+     * This function operates solely on columns at the top-level.
+     *
+     * Any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi] can be used as receiver for these functions.
+     *
+     * NOTE: To avoid ambiguity, `takeWhile` is called
+     * `takeColsWhile` when called on a [String] or [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath] resembling
+     * a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * ### Check out: [Usage]
+     *
+     * #### Examples:
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { `[`cols`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]` { "my" `[`in`][String.contains]` it.`[`name`][org.jetbrains.kotlinx.dataframe.DataColumn.name]` }.`[`takeWhile`][ColumnSet.takeWhile]` { "my" `[`in`][String.contains]` it.`[`name`][org.jetbrains.kotlinx.dataframe.DataColumn.name]` } }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[`takeWhile`][SingleColumn.takeColsWhile]` { it.`[`any`][org.jetbrains.kotlinx.dataframe.DataColumn.any]` { it == "Alice" } } }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "myColumnGroup".`[`takeColsWhile`][String.takeColsWhile]` { it.`[`kind`][org.jetbrains.kotlinx.dataframe.DataColumn.kind]`() == `[`ColumnKind.Value`][org.jetbrains.kotlinx.dataframe.columns.ColumnKind.Value]` } }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][DataFrame.select]`  {  `[takeWhile][ColumnsSelectionDsl.takeWhile]` { it.`[any][ColumnWithPath.any]` { it == "Alice" } } }`
+     *
+     * @param [predicate] The [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter] to control which columns to take.
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing the first columns adhering to the [predicate].
+     */
+    public fun ColumnsSelectionDsl<*>.takeWhile(predicate: ColumnFilter<*>): ColumnSet<*> =
+        asSingleColumn().takeColsWhile(predicate)
+
+    /**
+     * ## Take (Cols) While
+     * This function takes the first columns from [this] adhering to the
+     * given [predicate] collecting the result into a [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet].
+     *
+     * This function operates solely on columns at the top-level.
+     *
+     * Any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi] can be used as receiver for these functions.
+     *
+     * NOTE: To avoid ambiguity, `takeWhile` is called
+     * `takeColsWhile` when called on a [String] or [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath] resembling
+     * a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * ### Check out: [Usage]
+     *
+     * #### Examples:
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { `[`cols`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]` { "my" `[`in`][String.contains]` it.`[`name`][org.jetbrains.kotlinx.dataframe.DataColumn.name]` }.`[`takeWhile`][ColumnSet.takeWhile]` { "my" `[`in`][String.contains]` it.`[`name`][org.jetbrains.kotlinx.dataframe.DataColumn.name]` } }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[`takeWhile`][SingleColumn.takeColsWhile]` { it.`[`any`][org.jetbrains.kotlinx.dataframe.DataColumn.any]` { it == "Alice" } } }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "myColumnGroup".`[`takeColsWhile`][String.takeColsWhile]` { it.`[`kind`][org.jetbrains.kotlinx.dataframe.DataColumn.kind]`() == `[`ColumnKind.Value`][org.jetbrains.kotlinx.dataframe.columns.ColumnKind.Value]` } }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][DataFrame.select]` { myColumnGroup.`[takeWhile][SingleColumn.takeColsWhile]` { it.`[name][ColumnWithPath.name]`.`[startsWith][String.startsWith]`("my") } }`
+     *
+     * @param [predicate] The [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter] to control which columns to take.
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing the first columns adhering to the [predicate].
+     */
+    public fun SingleColumn<DataRow<*>>.takeColsWhile(predicate: ColumnFilter<*>): ColumnSet<*> =
+        this.ensureIsColumnGroup().transformSingle { it.cols().takeWhile(predicate) }
+
+    /**
+     * ## Take (Cols) While
+     * This function takes the first columns from [this] adhering to the
+     * given [predicate] collecting the result into a [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet].
+     *
+     * This function operates solely on columns at the top-level.
+     *
+     * Any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi] can be used as receiver for these functions.
+     *
+     * NOTE: To avoid ambiguity, `takeWhile` is called
+     * `takeColsWhile` when called on a [String] or [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath] resembling
+     * a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * ### Check out: [Usage]
+     *
+     * #### Examples:
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { `[`cols`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]` { "my" `[`in`][String.contains]` it.`[`name`][org.jetbrains.kotlinx.dataframe.DataColumn.name]` }.`[`takeWhile`][ColumnSet.takeWhile]` { "my" `[`in`][String.contains]` it.`[`name`][org.jetbrains.kotlinx.dataframe.DataColumn.name]` } }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[`takeWhile`][SingleColumn.takeColsWhile]` { it.`[`any`][org.jetbrains.kotlinx.dataframe.DataColumn.any]` { it == "Alice" } } }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "myColumnGroup".`[`takeColsWhile`][String.takeColsWhile]` { it.`[`kind`][org.jetbrains.kotlinx.dataframe.DataColumn.kind]`() == `[`ColumnKind.Value`][org.jetbrains.kotlinx.dataframe.columns.ColumnKind.Value]` } }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][DataFrame.select]` { "myColumnGroup".`[takeColsWhile][String.takeColsWhile]` { it.`[name][ColumnWithPath.name]`.`[startsWith][String.startsWith]`("my") } }`
+     *
+     * @param [predicate] The [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter] to control which columns to take.
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing the first columns adhering to the [predicate].
+     */
+    public fun String.takeColsWhile(predicate: ColumnFilter<*>): ColumnSet<*> =
+        columnGroup(this).takeColsWhile(predicate)
+
+    /**
+     * ## Take (Cols) While
+     * This function takes the first columns from [this] adhering to the
+     * given [predicate] collecting the result into a [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet].
+     *
+     * This function operates solely on columns at the top-level.
+     *
+     * Any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi] can be used as receiver for these functions.
+     *
+     * NOTE: To avoid ambiguity, `takeWhile` is called
+     * `takeColsWhile` when called on a [String] or [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath] resembling
+     * a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * ### Check out: [Usage]
+     *
+     * #### Examples:
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { `[`cols`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]` { "my" `[`in`][String.contains]` it.`[`name`][org.jetbrains.kotlinx.dataframe.DataColumn.name]` }.`[`takeWhile`][ColumnSet.takeWhile]` { "my" `[`in`][String.contains]` it.`[`name`][org.jetbrains.kotlinx.dataframe.DataColumn.name]` } }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[`takeWhile`][SingleColumn.takeColsWhile]` { it.`[`any`][org.jetbrains.kotlinx.dataframe.DataColumn.any]` { it == "Alice" } } }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "myColumnGroup".`[`takeColsWhile`][String.takeColsWhile]` { it.`[`kind`][org.jetbrains.kotlinx.dataframe.DataColumn.kind]`() == `[`ColumnKind.Value`][org.jetbrains.kotlinx.dataframe.columns.ColumnKind.Value]` } }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][DataFrame.select]` { Type::myColumnGroup.`[takeColsWhile][SingleColumn.takeColsWhile]` { it.`[name][ColumnWithPath.name]`.`[startsWith][String.startsWith]`("my") } }`
+     *
+     * `df.`[select][DataFrame.select]` { DataSchemaType::myColumnGroup.`[takeColsWhile][KProperty.takeColsWhile]` { it.`[any][ColumnWithPath.any]` { it == "Alice" } } }`
+     *
+     * @param [predicate] The [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter] to control which columns to take.
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing the first columns adhering to the [predicate].
+     */
+    public fun KProperty<*>.takeColsWhile(predicate: ColumnFilter<*>): ColumnSet<*> =
+        columnGroup(this).takeColsWhile(predicate)
+
+    /**
+     * ## Take (Cols) While
+     * This function takes the first columns from [this] adhering to the
+     * given [predicate] collecting the result into a [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet].
+     *
+     * This function operates solely on columns at the top-level.
+     *
+     * Any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi] can be used as receiver for these functions.
+     *
+     * NOTE: To avoid ambiguity, `takeWhile` is called
+     * `takeColsWhile` when called on a [String] or [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath] resembling
+     * a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * ### Check out: [Usage]
+     *
+     * #### Examples:
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { `[`cols`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]` { "my" `[`in`][String.contains]` it.`[`name`][org.jetbrains.kotlinx.dataframe.DataColumn.name]` }.`[`takeWhile`][ColumnSet.takeWhile]` { "my" `[`in`][String.contains]` it.`[`name`][org.jetbrains.kotlinx.dataframe.DataColumn.name]` } }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[`takeWhile`][SingleColumn.takeColsWhile]` { it.`[`any`][org.jetbrains.kotlinx.dataframe.DataColumn.any]` { it == "Alice" } } }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "myColumnGroup".`[`takeColsWhile`][String.takeColsWhile]` { it.`[`kind`][org.jetbrains.kotlinx.dataframe.DataColumn.kind]`() == `[`ColumnKind.Value`][org.jetbrains.kotlinx.dataframe.columns.ColumnKind.Value]` } }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][DataFrame.select]` { "pathTo"["myColumnGroup"].`[takeColsWhile][ColumnPath.takeColsWhile]` { it.`[name][ColumnWithPath.name]`.`[startsWith][String.startsWith]`("my") } }`
+     *
+     * @param [predicate] The [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter] to control which columns to take.
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing the first columns adhering to the [predicate].
+     */
+    public fun ColumnPath.takeColsWhile(predicate: ColumnFilter<*>): ColumnSet<*> =
+        columnGroup(this).takeColsWhile(predicate)
+
+    // endregion
+
+    // region takeLastWhile
+
+    /**
+     * ## Take Last (Cols) While
+     * This function takes the last columns from [this] adhering to the
+     * given [predicate] collecting the result into a [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet].
+     *
+     * This function operates solely on columns at the top-level.
+     *
+     * Any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi] can be used as receiver for these functions.
+     *
+     * NOTE: To avoid ambiguity, `takeLastWhile` is called
+     * `takeLastColsWhile` when called on a [String] or [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath] resembling
+     * a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * ### Check out: [Usage]
+     *
+     * #### Examples:
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { `[`cols`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]` { "my" `[`in`][String.contains]` it.`[`name`][org.jetbrains.kotlinx.dataframe.DataColumn.name]` }.`[`takeLastWhile`][ColumnSet.takeLastWhile]` { "my" `[`in`][String.contains]` it.`[`name`][org.jetbrains.kotlinx.dataframe.DataColumn.name]` } }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[`takeLastWhile`][SingleColumn.takeLastColsWhile]` { it.`[`any`][org.jetbrains.kotlinx.dataframe.DataColumn.any]` { it == "Alice" } } }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "myColumnGroup".`[`takeLastColsWhile`][String.takeLastColsWhile]` { it.`[`kind`][org.jetbrains.kotlinx.dataframe.DataColumn.kind]`() == `[`ColumnKind.Value`][org.jetbrains.kotlinx.dataframe.columns.ColumnKind.Value]` } }`
+     *
+     * #### Examples for this overload:
+     *
+     *
+     *
+     * @param [predicate] The [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter] to control which columns to take.
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing the last columns adhering to the [predicate].
+     */
+    private interface CommonTakeLastWhileDocs
+
+    /**
+     * ## Take Last (Cols) While
+     * This function takes the last columns from [this] adhering to the
+     * given [predicate] collecting the result into a [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet].
+     *
+     * This function operates solely on columns at the top-level.
+     *
+     * Any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi] can be used as receiver for these functions.
+     *
+     * NOTE: To avoid ambiguity, `takeLastWhile` is called
+     * `takeLastColsWhile` when called on a [String] or [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath] resembling
+     * a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * ### Check out: [Usage]
+     *
+     * #### Examples:
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { `[`cols`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]` { "my" `[`in`][String.contains]` it.`[`name`][org.jetbrains.kotlinx.dataframe.DataColumn.name]` }.`[`takeLastWhile`][ColumnSet.takeLastWhile]` { "my" `[`in`][String.contains]` it.`[`name`][org.jetbrains.kotlinx.dataframe.DataColumn.name]` } }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[`takeLastWhile`][SingleColumn.takeLastColsWhile]` { it.`[`any`][org.jetbrains.kotlinx.dataframe.DataColumn.any]` { it == "Alice" } } }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "myColumnGroup".`[`takeLastColsWhile`][String.takeLastColsWhile]` { it.`[`kind`][org.jetbrains.kotlinx.dataframe.DataColumn.kind]`() == `[`ColumnKind.Value`][org.jetbrains.kotlinx.dataframe.columns.ColumnKind.Value]` } }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][DataFrame.select]`  {  `[colsOf][SingleColumn.colsOf]`<`[String][String]`>().`[takeLastWhile][ColumnSet.takeLastWhile]` { it.`[any][ColumnWithPath.any]` { it == "Alice" } } }`
+     *
+     * `df.`[select][DataFrame.select]`  {  `[cols][ColumnsSelectionDsl.cols]` { .. }.`[takeLastWhile][ColumnSet.takeLastWhile]` { it.`[name][ColumnWithPath.name]`.`[startsWith][String.startsWith]`("my") } }`
+     *
+     * @param [predicate] The [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter] to control which columns to take.
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing the last columns adhering to the [predicate].
+     */
+    public fun <C> ColumnSet<C>.takeLastWhile(predicate: ColumnFilter<C>): ColumnSet<C> =
+        transform { it.takeLastWhile(predicate) }
+
+    /**
+     * ## Take Last (Cols) While
+     * This function takes the last columns from [this] adhering to the
+     * given [predicate] collecting the result into a [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet].
+     *
+     * This function operates solely on columns at the top-level.
+     *
+     * Any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi] can be used as receiver for these functions.
+     *
+     * NOTE: To avoid ambiguity, `takeLastWhile` is called
+     * `takeLastColsWhile` when called on a [String] or [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath] resembling
+     * a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * ### Check out: [Usage]
+     *
+     * #### Examples:
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { `[`cols`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]` { "my" `[`in`][String.contains]` it.`[`name`][org.jetbrains.kotlinx.dataframe.DataColumn.name]` }.`[`takeLastWhile`][ColumnSet.takeLastWhile]` { "my" `[`in`][String.contains]` it.`[`name`][org.jetbrains.kotlinx.dataframe.DataColumn.name]` } }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[`takeLastWhile`][SingleColumn.takeLastColsWhile]` { it.`[`any`][org.jetbrains.kotlinx.dataframe.DataColumn.any]` { it == "Alice" } } }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "myColumnGroup".`[`takeLastColsWhile`][String.takeLastColsWhile]` { it.`[`kind`][org.jetbrains.kotlinx.dataframe.DataColumn.kind]`() == `[`ColumnKind.Value`][org.jetbrains.kotlinx.dataframe.columns.ColumnKind.Value]` } }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][DataFrame.select]`  {  `[takeLastWhile][ColumnsSelectionDsl.takeLastWhile]` { it.`[any][ColumnWithPath.any]` { it == "Alice" } } }`
+     *
+     * @param [predicate] The [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter] to control which columns to take.
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing the last columns adhering to the [predicate].
+     */
+    public fun ColumnsSelectionDsl<*>.takeLastWhile(predicate: ColumnFilter<*>): ColumnSet<*> =
+        asSingleColumn().takeLastColsWhile(predicate)
+
+    /**
+     * ## Take Last (Cols) While
+     * This function takes the last columns from [this] adhering to the
+     * given [predicate] collecting the result into a [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet].
+     *
+     * This function operates solely on columns at the top-level.
+     *
+     * Any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi] can be used as receiver for these functions.
+     *
+     * NOTE: To avoid ambiguity, `takeLastWhile` is called
+     * `takeLastColsWhile` when called on a [String] or [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath] resembling
+     * a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * ### Check out: [Usage]
+     *
+     * #### Examples:
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { `[`cols`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]` { "my" `[`in`][String.contains]` it.`[`name`][org.jetbrains.kotlinx.dataframe.DataColumn.name]` }.`[`takeLastWhile`][ColumnSet.takeLastWhile]` { "my" `[`in`][String.contains]` it.`[`name`][org.jetbrains.kotlinx.dataframe.DataColumn.name]` } }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[`takeLastWhile`][SingleColumn.takeLastColsWhile]` { it.`[`any`][org.jetbrains.kotlinx.dataframe.DataColumn.any]` { it == "Alice" } } }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "myColumnGroup".`[`takeLastColsWhile`][String.takeLastColsWhile]` { it.`[`kind`][org.jetbrains.kotlinx.dataframe.DataColumn.kind]`() == `[`ColumnKind.Value`][org.jetbrains.kotlinx.dataframe.columns.ColumnKind.Value]` } }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][DataFrame.select]` { myColumnGroup.`[takeLastColsWhile][SingleColumn.takeLastColsWhile]` { it.`[name][ColumnWithPath.name]`.`[startsWith][String.startsWith]`("my") } }`
+     *
+     * @param [predicate] The [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter] to control which columns to take.
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing the last columns adhering to the [predicate].
+     */
+    public fun SingleColumn<DataRow<*>>.takeLastColsWhile(predicate: ColumnFilter<*>): ColumnSet<*> =
+        this.ensureIsColumnGroup().transformSingle { it.cols().takeLastWhile(predicate) }
+
+    /**
+     * ## Take Last (Cols) While
+     * This function takes the last columns from [this] adhering to the
+     * given [predicate] collecting the result into a [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet].
+     *
+     * This function operates solely on columns at the top-level.
+     *
+     * Any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi] can be used as receiver for these functions.
+     *
+     * NOTE: To avoid ambiguity, `takeLastWhile` is called
+     * `takeLastColsWhile` when called on a [String] or [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath] resembling
+     * a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * ### Check out: [Usage]
+     *
+     * #### Examples:
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { `[`cols`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]` { "my" `[`in`][String.contains]` it.`[`name`][org.jetbrains.kotlinx.dataframe.DataColumn.name]` }.`[`takeLastWhile`][ColumnSet.takeLastWhile]` { "my" `[`in`][String.contains]` it.`[`name`][org.jetbrains.kotlinx.dataframe.DataColumn.name]` } }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[`takeLastWhile`][SingleColumn.takeLastColsWhile]` { it.`[`any`][org.jetbrains.kotlinx.dataframe.DataColumn.any]` { it == "Alice" } } }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "myColumnGroup".`[`takeLastColsWhile`][String.takeLastColsWhile]` { it.`[`kind`][org.jetbrains.kotlinx.dataframe.DataColumn.kind]`() == `[`ColumnKind.Value`][org.jetbrains.kotlinx.dataframe.columns.ColumnKind.Value]` } }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][DataFrame.select]` { "myColumnGroup".`[takeLastColsWhile][String.takeLastColsWhile]` { it.`[name][ColumnWithPath.name]`.`[startsWith][String.startsWith]`("my") } }`
+     *
+     * @param [predicate] The [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter] to control which columns to take.
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing the last columns adhering to the [predicate].
+     */
+    public fun String.takeLastColsWhile(predicate: ColumnFilter<*>): ColumnSet<*> =
+        columnGroup(this).takeLastColsWhile(predicate)
+
+    /**
+     * ## Take Last (Cols) While
+     * This function takes the last columns from [this] adhering to the
+     * given [predicate] collecting the result into a [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet].
+     *
+     * This function operates solely on columns at the top-level.
+     *
+     * Any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi] can be used as receiver for these functions.
+     *
+     * NOTE: To avoid ambiguity, `takeLastWhile` is called
+     * `takeLastColsWhile` when called on a [String] or [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath] resembling
+     * a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * ### Check out: [Usage]
+     *
+     * #### Examples:
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { `[`cols`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]` { "my" `[`in`][String.contains]` it.`[`name`][org.jetbrains.kotlinx.dataframe.DataColumn.name]` }.`[`takeLastWhile`][ColumnSet.takeLastWhile]` { "my" `[`in`][String.contains]` it.`[`name`][org.jetbrains.kotlinx.dataframe.DataColumn.name]` } }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[`takeLastWhile`][SingleColumn.takeLastColsWhile]` { it.`[`any`][org.jetbrains.kotlinx.dataframe.DataColumn.any]` { it == "Alice" } } }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "myColumnGroup".`[`takeLastColsWhile`][String.takeLastColsWhile]` { it.`[`kind`][org.jetbrains.kotlinx.dataframe.DataColumn.kind]`() == `[`ColumnKind.Value`][org.jetbrains.kotlinx.dataframe.columns.ColumnKind.Value]` } }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][DataFrame.select]` { Type::myColumnGroup.`[takeLastColsWhile][SingleColumn.takeLastColsWhile]` { it.`[name][ColumnWithPath.name]`.`[startsWith][String.startsWith]`("my") } }`
+     *
+     * `df.`[select][DataFrame.select]` { DataSchemaType::myColumnGroup.`[takeLastColsWhile][KProperty.takeLastColsWhile]` { it.`[any][ColumnWithPath.any]` { it == "Alice" } } }`
+     *
+     * @param [predicate] The [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter] to control which columns to take.
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing the last columns adhering to the [predicate].
+     */
+    public fun KProperty<*>.takeLastColsWhile(predicate: ColumnFilter<*>): ColumnSet<*> =
+        columnGroup(this).takeLastColsWhile(predicate)
+
+    /**
+     * ## Take Last (Cols) While
+     * This function takes the last columns from [this] adhering to the
+     * given [predicate] collecting the result into a [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet].
+     *
+     * This function operates solely on columns at the top-level.
+     *
+     * Any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi] can be used as receiver for these functions.
+     *
+     * NOTE: To avoid ambiguity, `takeLastWhile` is called
+     * `takeLastColsWhile` when called on a [String] or [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath] resembling
+     * a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * ### Check out: [Usage]
+     *
+     * #### Examples:
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { `[`cols`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]` { "my" `[`in`][String.contains]` it.`[`name`][org.jetbrains.kotlinx.dataframe.DataColumn.name]` }.`[`takeLastWhile`][ColumnSet.takeLastWhile]` { "my" `[`in`][String.contains]` it.`[`name`][org.jetbrains.kotlinx.dataframe.DataColumn.name]` } }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[`takeLastWhile`][SingleColumn.takeLastColsWhile]` { it.`[`any`][org.jetbrains.kotlinx.dataframe.DataColumn.any]` { it == "Alice" } } }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "myColumnGroup".`[`takeLastColsWhile`][String.takeLastColsWhile]` { it.`[`kind`][org.jetbrains.kotlinx.dataframe.DataColumn.kind]`() == `[`ColumnKind.Value`][org.jetbrains.kotlinx.dataframe.columns.ColumnKind.Value]` } }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][DataFrame.select]` { "pathTo"["myColumnGroup"].`[takeLastColsWhile][ColumnPath.takeLastColsWhile]` { it.`[name][ColumnWithPath.name]`.`[startsWith][String.startsWith]`("my") } }`
+     *
+     * @param [predicate] The [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter] to control which columns to take.
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing the last columns adhering to the [predicate].
+     */
+    public fun ColumnPath.takeLastColsWhile(predicate: ColumnFilter<*>): ColumnSet<*> =
+        columnGroup(this).takeLastColsWhile(predicate)
+
+    // endregion
+}
+
+// endregion
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/toDataFrame.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/toDataFrame.kt
new file mode 100644
index 000000000..cdc56fccb
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/toDataFrame.kt
@@ -0,0 +1,332 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import org.jetbrains.kotlinx.dataframe.AnyBaseCol
+import org.jetbrains.kotlinx.dataframe.AnyFrame
+import org.jetbrains.kotlinx.dataframe.DataColumn
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.DataRow
+import org.jetbrains.kotlinx.dataframe.annotations.DataSchema
+import org.jetbrains.kotlinx.dataframe.annotations.Interpretable
+import org.jetbrains.kotlinx.dataframe.annotations.Refine
+import org.jetbrains.kotlinx.dataframe.columns.ColumnPath
+import org.jetbrains.kotlinx.dataframe.impl.ColumnNameGenerator
+import org.jetbrains.kotlinx.dataframe.impl.api.createDataFrameImpl
+import org.jetbrains.kotlinx.dataframe.impl.asList
+import org.jetbrains.kotlinx.dataframe.impl.columnName
+import org.jetbrains.kotlinx.dataframe.impl.columns.guessColumnType
+import org.jetbrains.kotlinx.dataframe.index
+import kotlin.reflect.KCallable
+import kotlin.reflect.KClass
+import kotlin.reflect.KProperty
+
+// region read DataFrame from objects
+
+@Refine
+@Interpretable("toDataFrameDefault")
+public inline fun <reified T> Iterable<T>.toDataFrame(): DataFrame<T> =
+    toDataFrame {
+        properties()
+    }
+
+@Refine
+@Interpretable("toDataFrameDsl")
+public inline fun <reified T> Iterable<T>.toDataFrame(noinline body: CreateDataFrameDsl<T>.() -> Unit): DataFrame<T> =
+    createDataFrameImpl(T::class, body)
+
+@Refine
+@Interpretable("toDataFrame")
+public inline fun <reified T> Iterable<T>.toDataFrame(vararg props: KProperty<*>, maxDepth: Int = 0): DataFrame<T> =
+    toDataFrame {
+        properties(roots = props, maxDepth = maxDepth)
+    }
+
+@JvmName("toDataFrameT")
+public fun <T> Iterable<DataRow<T>>.toDataFrame(): DataFrame<T> {
+    var uniqueDf: DataFrame<T>? = null
+    for (row in this) {
+        if (uniqueDf == null) {
+            uniqueDf = row.df()
+        } else {
+            if (uniqueDf !== row.df()) {
+                uniqueDf = null
+                break
+            }
+        }
+    }
+    return if (uniqueDf != null) {
+        val permutation = map { it.index }
+        uniqueDf[permutation]
+    } else {
+        map { it.toDataFrame() }.concat()
+    }
+}
+
+@JvmName("toDataFrameAnyColumn")
+public fun Iterable<AnyBaseCol>.toDataFrame(): AnyFrame = dataFrameOf(this)
+
+@JvmName("toDataFramePairColumnPathAnyCol")
+public fun <T> Iterable<Pair<ColumnPath, AnyBaseCol>>.toDataFrameFromPairs(): DataFrame<T> {
+    val nameGenerator = ColumnNameGenerator()
+    val columnNames = mutableListOf<String>()
+    val columnGroups = mutableListOf<MutableList<Pair<ColumnPath, AnyBaseCol>>?>()
+    val columns = mutableListOf<AnyBaseCol?>()
+    val columnIndices = mutableMapOf<String, Int>()
+    val columnGroupName = mutableMapOf<String, String>()
+
+    forEach { (path, col) ->
+        when (path.size) {
+            0 -> {
+            }
+
+            1 -> {
+                val name = path[0]
+                val uniqueName = nameGenerator.addUnique(name)
+                val index = columns.size
+                columnNames.add(uniqueName)
+                columnGroups.add(null)
+                columns.add(col.rename(uniqueName))
+                columnIndices[uniqueName] = index
+            }
+
+            else -> {
+                val name = path[0]
+                val uniqueName = columnGroupName.getOrPut(name) {
+                    nameGenerator.addUnique(name)
+                }
+                val index = columnIndices.getOrPut(uniqueName) {
+                    columnNames.add(uniqueName)
+                    columnGroups.add(mutableListOf())
+                    columns.add(null)
+                    columns.size - 1
+                }
+                val list = columnGroups[index]!!
+                list.add(path.drop(1) to col)
+            }
+        }
+    }
+    columns.indices.forEach { index ->
+        val group = columnGroups[index]
+        if (group != null) {
+            val nestedDf = group.toDataFrameFromPairs<Unit>()
+            val col = DataColumn.createColumnGroup(columnNames[index], nestedDf)
+            assert(columns[index] == null)
+            columns[index] = col
+        } else {
+            assert(columns[index] != null)
+        }
+    }
+    return columns.map { it!! }.toDataFrame().cast()
+}
+
+@JvmName("toDataFrameColumnPathAnyNullable")
+public fun Iterable<Pair<ColumnPath, Iterable<Any?>>>.toDataFrameFromPairs(): AnyFrame =
+    map {
+        it.first to guessColumnType(it.first.last(), it.second.asList())
+    }.toDataFrameFromPairs<Unit>()
+
+public fun Iterable<Pair<String, Iterable<Any?>>>.toDataFrameFromPairs(): AnyFrame =
+    map {
+        ColumnPath(it.first) to guessColumnType(it.first, it.second.asList())
+    }.toDataFrameFromPairs<Unit>()
+
+public interface TraversePropertiesDsl {
+
+    /**
+     * Skip given [classes] during recursive (dfs) traversal.
+     */
+    @Interpretable("Exclude0")
+    public fun exclude(vararg classes: KClass<*>)
+
+    /**
+     * Skip given [properties] during recursive (dfs) traversal.
+     * These can also be getter-like functions (like `getX()` or `isX()`).
+     */
+    @Interpretable("Exclude1")
+    public fun exclude(vararg properties: KCallable<*>)
+
+    /**
+     * Store given [classes] in ValueColumns without transformation into ColumnGroups or FrameColumns.
+     */
+    @Interpretable("Preserve0")
+    public fun preserve(vararg classes: KClass<*>)
+
+    /**
+     * Store given [properties] in ValueColumns without transformation into ColumnGroups or FrameColumns.
+     * These can also be getter-like functions (like `getX()` or `isX()`).
+     */
+    @Interpretable("Preserve1")
+    public fun preserve(vararg properties: KCallable<*>)
+}
+
+public inline fun <reified T> TraversePropertiesDsl.preserve(): Unit = preserve(T::class)
+
+public abstract class CreateDataFrameDsl<T> : TraversePropertiesDsl {
+
+    public abstract val source: Iterable<T>
+
+    public abstract fun add(column: AnyBaseCol, path: ColumnPath? = null)
+
+    public infix fun AnyBaseCol.into(name: String): Unit = add(this, pathOf(name))
+
+    public infix fun AnyBaseCol.into(path: ColumnPath): Unit = add(this, path)
+
+    @Interpretable("Properties0")
+    public abstract fun properties(
+        vararg roots: KCallable<*>,
+        maxDepth: Int = 0,
+        body: (TraversePropertiesDsl.() -> Unit)? = null,
+    )
+
+    public inline fun <reified R> expr(infer: Infer = Infer.Nulls, noinline expression: (T) -> R): DataColumn<R> =
+        source.map { expression(it) }.toColumn(infer = infer)
+
+    public inline fun <reified R> add(name: String, noinline expression: (T) -> R): Unit =
+        add(source.map { expression(it) }.toColumn(name, Infer.Nulls))
+
+    @Interpretable("ToDataFrameFrom0")
+    public inline infix fun <reified R> String.from(noinline expression: (T) -> R): Unit = add(this, expression)
+
+    public inline infix fun <reified R> KProperty<R>.from(noinline expression: (T) -> R): Unit =
+        add(columnName, expression)
+
+    public inline infix fun <reified R> String.from(inferType: InferType<T, R>): Unit =
+        add(DataColumn.createWithTypeInference(this, source.map { inferType.expression(it) }))
+
+    public inline infix fun <reified R> KProperty<R>.from(inferType: InferType<T, R>): Unit =
+        add(DataColumn.createWithTypeInference(columnName, source.map { inferType.expression(it) }))
+
+    public data class InferType<T, R>(val expression: (T) -> R)
+
+    public inline fun <reified R> inferType(noinline expression: (T) -> R): InferType<T, R> = InferType(expression)
+
+    public abstract operator fun String.invoke(builder: CreateDataFrameDsl<T>.() -> Unit)
+}
+
+@Refine
+@Interpretable("ToDataFrameColumn")
+public inline fun <reified T> Iterable<T>.toDataFrame(columnName: String): DataFrame<*> =
+    toDataFrame {
+        columnName from { it }
+    }
+
+// endregion
+
+// region toDataFrame overloads for built-in types
+
+/*
+Without overloads Iterable<String>.toDataFrame produces unexpected result
+
+
+```
+val string = listOf("aaa", "aa", null)
+string.toDataFrame()
+```
+=>
+  length
+0    3
+1    2
+2 null
+ */
+
+@JvmName("toDataFrameByte")
+public inline fun <reified B : Byte?> Iterable<B>.toDataFrame(): DataFrame<ValueProperty<B>> =
+    toDataFrame {
+        ValueProperty<B>::value from { it }
+    }.cast()
+
+@JvmName("toDataFrameShort")
+public inline fun <reified S : Short?> Iterable<S>.toDataFrame(): DataFrame<ValueProperty<S>> =
+    toDataFrame {
+        ValueProperty<S>::value from { it }
+    }.cast()
+
+@JvmName("toDataFrameInt")
+public inline fun <reified I : Int?> Iterable<I>.toDataFrame(): DataFrame<ValueProperty<I>> =
+    toDataFrame {
+        ValueProperty<I>::value from { it }
+    }.cast()
+
+@JvmName("toDataFrameLong")
+public inline fun <reified L : Long?> Iterable<L>.toDataFrame(): DataFrame<ValueProperty<L>> =
+    toDataFrame {
+        ValueProperty<L>::value from { it }
+    }.cast()
+
+@JvmName("toDataFrameString")
+public inline fun <reified S : String?> Iterable<S>.toDataFrame(): DataFrame<ValueProperty<S>> =
+    toDataFrame {
+        ValueProperty<S>::value from { it }
+    }.cast()
+
+@JvmName("toDataFrameChar")
+public inline fun <reified C : Char?> Iterable<C>.toDataFrame(): DataFrame<ValueProperty<C>> =
+    toDataFrame {
+        ValueProperty<C>::value from { it }
+    }.cast()
+
+@JvmName("toDataFrameBoolean")
+public inline fun <reified B : Boolean?> Iterable<B>.toDataFrame(): DataFrame<ValueProperty<B>> =
+    toDataFrame {
+        ValueProperty<B>::value from { it }
+    }.cast()
+
+@JvmName("toDataFrameFloat")
+public inline fun <reified F : Float?> Iterable<F>.toDataFrame(): DataFrame<ValueProperty<F>> =
+    toDataFrame {
+        ValueProperty<F>::value from { it }
+    }.cast()
+
+@JvmName("toDataFrameDouble")
+public inline fun <reified D : Double?> Iterable<D>.toDataFrame(): DataFrame<ValueProperty<D>> =
+    toDataFrame {
+        ValueProperty<D>::value from { it }
+    }.cast()
+
+@JvmName("toDataFrameUByte")
+public inline fun <reified U : UByte?> Iterable<U>.toDataFrame(): DataFrame<ValueProperty<U>> =
+    toDataFrame {
+        ValueProperty<U>::value from { it }
+    }.cast()
+
+@JvmName("toDataFrameUShort")
+public inline fun <reified U : UShort?> Iterable<U>.toDataFrame(): DataFrame<ValueProperty<U>> =
+    toDataFrame {
+        ValueProperty<U>::value from { it }
+    }.cast()
+
+@JvmName("toDataFrameUInt")
+public inline fun <reified U : UInt?> Iterable<U>.toDataFrame(): DataFrame<ValueProperty<U>> =
+    toDataFrame {
+        ValueProperty<U>::value from { it }
+    }.cast()
+
+@JvmName("toDataFrameULong")
+public inline fun <reified U : ULong?> Iterable<U>.toDataFrame(): DataFrame<ValueProperty<U>> =
+    toDataFrame {
+        ValueProperty<U>::value from { it }
+    }.cast()
+
+@DataSchema
+public interface ValueProperty<T> {
+    public val value: T
+}
+
+// endregion
+
+// region Create DataFrame from Map
+
+public fun Map<String, Iterable<Any?>>.toDataFrame(): AnyFrame =
+    map {
+        DataColumn.createWithTypeInference(it.key, it.value.asList())
+    }.toDataFrame()
+
+@JvmName("toDataFrameColumnPathAnyNullable")
+public fun Map<ColumnPath, Iterable<Any?>>.toDataFrame(): AnyFrame =
+    map {
+        it.key to DataColumn.createWithTypeInference(
+            name = it.key.last(),
+            values = it.value.asList(),
+        )
+    }.toDataFrameFromPairs<Unit>()
+
+// endregion
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/toList.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/toList.kt
new file mode 100644
index 000000000..b9eb5a873
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/toList.kt
@@ -0,0 +1,14 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import org.jetbrains.kotlinx.dataframe.AnyFrame
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.impl.api.toListImpl
+import kotlin.reflect.typeOf
+
+// region DataFrame
+
+public inline fun <reified T> DataFrame<T>.toList(): List<T> = toListImpl(typeOf<T>()) as List<T>
+
+public inline fun <reified T> AnyFrame.toListOf(): List<T> = toListImpl(typeOf<T>()) as List<T>
+
+// endregion
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/transpose.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/transpose.kt
new file mode 100644
index 000000000..774bea2f7
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/transpose.kt
@@ -0,0 +1,32 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import org.jetbrains.kotlinx.dataframe.AnyRow
+import org.jetbrains.kotlinx.dataframe.DataColumn
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.DataRow
+import org.jetbrains.kotlinx.dataframe.impl.api.convertTo
+import org.jetbrains.kotlinx.dataframe.impl.columnName
+import org.jetbrains.kotlinx.dataframe.impl.owner
+import org.jetbrains.kotlinx.dataframe.values
+import kotlin.reflect.KType
+import kotlin.reflect.typeOf
+
+// region DataRow
+
+public fun <T> DataRow<T>.transpose(): DataFrame<NameValuePair<*>> {
+    val valueColumn = DataColumn.createWithTypeInference(NameValuePair<*>::value.columnName, values)
+    val nameColumn = owner.columnNames().toValueColumn(NameValuePair<*>::name)
+    return dataFrameOf(nameColumn, valueColumn).cast()
+}
+
+public inline fun <reified T> AnyRow.transposeTo(): DataFrame<NameValuePair<T>> = transposeTo(typeOf<T>())
+
+@PublishedApi
+internal fun <T> AnyRow.transposeTo(type: KType): DataFrame<NameValuePair<T>> {
+    val convertedValues = values.map { it?.convertTo(type) as T? }
+    val valueColumn = DataColumn.createWithTypeInference(NameValuePair<T>::value.columnName, convertedValues)
+    val nameColumn = owner.columnNames().toValueColumn(NameValuePair<T>::name)
+    return dataFrameOf(nameColumn, valueColumn).cast()
+}
+
+// endregion
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/unfold.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/unfold.kt
new file mode 100644
index 000000000..837154cce
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/unfold.kt
@@ -0,0 +1,34 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import org.jetbrains.kotlinx.dataframe.AnyCol
+import org.jetbrains.kotlinx.dataframe.AnyColumnReference
+import org.jetbrains.kotlinx.dataframe.ColumnsSelector
+import org.jetbrains.kotlinx.dataframe.DataColumn
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.columns.ColumnKind
+import org.jetbrains.kotlinx.dataframe.columns.toColumnSet
+import org.jetbrains.kotlinx.dataframe.impl.api.createDataFrameImpl
+import org.jetbrains.kotlinx.dataframe.typeClass
+import kotlin.reflect.KProperty
+
+public inline fun <reified T> DataColumn<T>.unfold(): AnyCol =
+    when (kind()) {
+        ColumnKind.Group, ColumnKind.Frame -> this
+
+        else -> when {
+            isPrimitive() -> this
+
+            else -> values()
+                .createDataFrameImpl(typeClass) { (this as CreateDataFrameDsl<T>).properties() }
+                .asColumnGroup(name())
+                .asDataColumn()
+        }
+    }
+
+public fun <T> DataFrame<T>.unfold(columns: ColumnsSelector<T, *>): DataFrame<T> = replace(columns).with { it.unfold() }
+
+public fun <T> DataFrame<T>.unfold(vararg columns: String): DataFrame<T> = unfold { columns.toColumnSet() }
+
+public fun <T> DataFrame<T>.unfold(vararg columns: AnyColumnReference): DataFrame<T> = unfold { columns.toColumnSet() }
+
+public fun <T> DataFrame<T>.unfold(vararg columns: KProperty<*>): DataFrame<T> = unfold { columns.toColumnSet() }
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/ungroup.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/ungroup.kt
new file mode 100644
index 000000000..8f0311c53
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/ungroup.kt
@@ -0,0 +1,28 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import org.jetbrains.kotlinx.dataframe.AnyColumnReference
+import org.jetbrains.kotlinx.dataframe.ColumnsSelector
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.annotations.Interpretable
+import org.jetbrains.kotlinx.dataframe.annotations.Refine
+import org.jetbrains.kotlinx.dataframe.columns.toColumnSet
+import org.jetbrains.kotlinx.dataframe.impl.columns.toColumnSet
+import org.jetbrains.kotlinx.dataframe.impl.removeAt
+import kotlin.reflect.KProperty
+
+// region DataFrame
+
+@Refine
+@Interpretable("Ungroup0")
+public fun <T, C> DataFrame<T>.ungroup(columns: ColumnsSelector<T, C>): DataFrame<T> =
+    move { columns.toColumnSet().colsInGroups() }
+        .into { it.path.removeAt(it.path.size - 2).toPath() }
+
+public fun <T> DataFrame<T>.ungroup(vararg columns: String): DataFrame<T> = ungroup { columns.toColumnSet() }
+
+public fun <T> DataFrame<T>.ungroup(vararg columns: AnyColumnReference): DataFrame<T> =
+    ungroup { columns.toColumnSet() }
+
+public fun <T> DataFrame<T>.ungroup(vararg columns: KProperty<*>): DataFrame<T> = ungroup { columns.toColumnSet() }
+
+// endregion
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/update.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/update.kt
new file mode 100644
index 000000000..7c483713b
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/update.kt
@@ -0,0 +1,772 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import org.jetbrains.kotlinx.dataframe.AnyRow
+import org.jetbrains.kotlinx.dataframe.ColumnExpression
+import org.jetbrains.kotlinx.dataframe.ColumnsSelector
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.DataFrameExpression
+import org.jetbrains.kotlinx.dataframe.DataRow
+import org.jetbrains.kotlinx.dataframe.RowColumnExpression
+import org.jetbrains.kotlinx.dataframe.RowValueFilter
+import org.jetbrains.kotlinx.dataframe.annotations.Interpretable
+import org.jetbrains.kotlinx.dataframe.annotations.Refine
+import org.jetbrains.kotlinx.dataframe.api.Update.Grammar
+import org.jetbrains.kotlinx.dataframe.columns.ColumnGroup
+import org.jetbrains.kotlinx.dataframe.columns.ColumnReference
+import org.jetbrains.kotlinx.dataframe.columns.toColumnSet
+import org.jetbrains.kotlinx.dataframe.documentation.ExpressionsGivenColumn
+import org.jetbrains.kotlinx.dataframe.documentation.ExpressionsGivenDataFrame
+import org.jetbrains.kotlinx.dataframe.documentation.ExpressionsGivenRow
+import org.jetbrains.kotlinx.dataframe.documentation.ExpressionsGivenRowAndColumn
+import org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns
+import org.jetbrains.kotlinx.dataframe.documentation.SelectingRows
+import org.jetbrains.kotlinx.dataframe.impl.api.asFrameImpl
+import org.jetbrains.kotlinx.dataframe.impl.api.updateImpl
+import org.jetbrains.kotlinx.dataframe.impl.api.updateWithValuePerColumnImpl
+import org.jetbrains.kotlinx.dataframe.impl.headPlusArray
+import org.jetbrains.kotlinx.dataframe.index
+import kotlin.reflect.KProperty
+
+/**
+ * ## The Update Operation
+ *
+ * Returns the [DataFrame] with changed values in some cells
+ * (column types cannot be changed).
+ *
+ * ### Check out: [Grammar]
+ *
+ * For more information: [See `update` on the documentation website.](https://kotlin.github.io/dataframe/update.html)
+ */
+public class Update<T, C>(
+    internal val df: DataFrame<T>,
+    internal val filter: RowValueFilter<T, C>?,
+    internal val columns: ColumnsSelector<T, C>,
+) {
+    public fun <R : C> cast(): Update<T, R> =
+        Update(df, filter as RowValueFilter<T, R>?, columns as ColumnsSelector<T, R>)
+
+    override fun toString(): String = "Update(df=$df, filter=$filter, columns=$columns)"
+
+    /**
+     * ## [**`update`**][update] Operation Grammar
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * [(What is this notation?)][org.jetbrains.kotlinx.dataframe.documentation.DslGrammar]
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     * [**`update`**][update]**`  {  `**[`columns`][SelectingColumns]**` }`**
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     * `[ `__`.`__[**`where`**][Update.where]**`  {  `**[`rowValueCondition`][SelectingRows.RowValueCondition.WithExample]**`  }  `**`]`
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     * `[ `__`.`__[**`at`**][Update.at]**`(`**[`rowIndices`][CommonUpdateAtFunctionDoc.RowIndicesParam]**`)`**` ]`
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     * __`.`__[**`with`**][Update.with]**`  {  `**[`rowExpression`][ExpressionsGivenRow.RowValueExpression.WithExample]**` }`**
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     * `| `__`.`__[**`notNull`**][Update.notNull]**`  {  `**[`rowExpression`][ExpressionsGivenRow.RowValueExpression.WithExample]**` }`**
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     * `| `__`.`__[**`perCol`**][Update.perCol]**`  {  `**[`colExpression`][ExpressionsGivenColumn.ColumnExpression.WithExample]**` }`**
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     * `| `__`.`__[**`perRowCol`**][Update.perRowCol]**`  {  `**[`rowColExpression`][ExpressionsGivenRowAndColumn.RowColumnExpression.WithExample]**` }`**
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     * `| `__`.`__[**`withNull`**][Update.withNull]**`()`**
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     * `| `__`.`__[**`withZero`**][Update.withZero]**`()`**
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     * `| `__`.`__[**`asFrame`**][Update.asFrame]**`  {  `**[`dataFrameExpression`][ExpressionsGivenDataFrame.DataFrameExpression.WithExample]**` }`**
+     *
+     *
+     */
+    public interface Grammar
+
+    /**
+     * The columns to update need to be selected. See [Selecting Columns][UpdateSelectingOptions]
+     * for all the selecting options.
+     */
+    public interface Columns {
+
+        // Optional argument that can be set to redirect where the [Selecting Columns] link points to
+        public interface SelectingColumnsArg
+    }
+
+    /**
+     *
+     * ## Selecting Columns
+     * Selecting columns for various operations (including but not limited to
+     * [DataFrame.select][org.jetbrains.kotlinx.dataframe.DataFrame.select], [DataFrame.update][org.jetbrains.kotlinx.dataframe.DataFrame.update], [DataFrame.gather][org.jetbrains.kotlinx.dataframe.DataFrame.gather], and [DataFrame.fillNulls][org.jetbrains.kotlinx.dataframe.DataFrame.fillNulls])
+     * can be done in the following ways:
+     * ### 1. [Columns Selection DSL][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns.Dsl.WithExample]
+     * Select or express columns using the [Columns Selection DSL][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl].
+     * (Any (combination of) [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+     *
+     * This DSL is initiated by a [Columns Selector][org.jetbrains.kotlinx.dataframe.ColumnsSelector] lambda,
+     * which operates in the context of the [Columns Selection DSL][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl] and
+     * expects you to return a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn] or [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] (so, a [ColumnsResolver][org.jetbrains.kotlinx.dataframe.columns.ColumnsResolver]).
+     * This is an entity formed by calling any (combination) of the functions
+     * in the DSL that is or can be resolved into one or more columns.
+     *
+     * #### NOTE:
+     * While you can use the [String API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi.StringApi] and [KProperties API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi.KPropertiesApi]
+     * in this DSL directly with any function, they are NOT valid return types for the
+     * [Columns Selector][org.jetbrains.kotlinx.dataframe.ColumnsSelector] lambda. You'd need to turn them into a [ColumnReference][org.jetbrains.kotlinx.dataframe.columns.ColumnReference] first, for instance
+     * with a function like [`col("name")`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.col].
+     *
+     * ### Check out: [Columns Selection DSL Grammar][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.DslGrammar]
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * [See Column Selectors on the documentation website.](https://kotlin.github.io/dataframe/columnselectors.html)
+     *
+     * #### For example:
+     *
+     * `df.`[update][org.jetbrains.kotlinx.dataframe.api.update]` { length `[and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]` age }`
+     *
+     * `df.`[update][org.jetbrains.kotlinx.dataframe.api.update]`  {  `[cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`(1..5) }`
+     *
+     * `df.`[update][org.jetbrains.kotlinx.dataframe.api.update]`  {  `[colsOf][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[Double][Double]`>() }`
+     *
+     *
+     * #### NOTE: There's also a 'single column' variant used sometimes: [Column Selection DSL][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns.DslSingle.WithExample].
+     * ### 2. [Column names][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns.ColumnNames.WithExample]
+     * Select columns using their [column names][String]
+     * ([String API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi.StringApi]).
+     *
+     * #### For example:
+     *
+     * `df.`[update][org.jetbrains.kotlinx.dataframe.api.update]`("length", "age")`
+     *
+     * ### 3. [Column references][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns.ColumnAccessors.WithExample]
+     * Select columns using [column accessors][org.jetbrains.kotlinx.dataframe.columns.ColumnReference]
+     * ([Column Accessors API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi.ColumnAccessorsApi]).
+     *
+     * #### For example:
+     *
+     * `val length by `[column][org.jetbrains.kotlinx.dataframe.api.column]`<`[Double][Double]`>()`
+     *
+     * `val age by `[column][org.jetbrains.kotlinx.dataframe.api.column]`<`[Double][Double]`>()`
+     *
+     * `df.`[update][org.jetbrains.kotlinx.dataframe.api.update]`(length, age)`
+     *
+     * ### 4. [KProperties][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns.KProperties.WithExample]
+     * Select columns using [KProperties][KProperty] ([KProperties API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi.KPropertiesApi]).
+     *
+     * #### For example:
+     * ```kotlin
+     * data class Person(val length: Double, val age: Double)
+     * ```
+     *
+     * `df.`[update][org.jetbrains.kotlinx.dataframe.api.update]`(Person::length, Person::age)`
+     *
+     */
+    public interface UpdateSelectingOptions
+
+    /** @param [columns] The [Columns Selector][ColumnsSelector] used to select the columns of this [DataFrame] to update. */
+    internal interface DslParam
+
+    /** @param [columns] The [Column References][ColumnReference] of this [DataFrame] to update. */
+    internal interface ColumnAccessorsParam
+
+    /** @param [columns] The [KProperties][KProperty] corresponding to columns of this [DataFrame] to update. */
+    internal interface KPropertiesParam
+
+    /** @param [columns] The [Strings][String] corresponding to the names of columns belonging to this [DataFrame] to update. */
+    internal interface ColumnNamesParam
+}
+
+// region update
+
+/**
+ * ## The Update Operation
+ *
+ * Returns the [DataFrame][org.jetbrains.kotlinx.dataframe.DataFrame] with changed values in some cells
+ * (column types cannot be changed).
+ *
+ * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.Update.Grammar]
+ *
+ * For more information: [See `update` on the documentation website.](https://kotlin.github.io/dataframe/update.html)
+ *
+ * &nbsp;&nbsp;&nbsp;&nbsp;
+ *
+ * The columns to update need to be selected. See [Selecting Columns][org.jetbrains.kotlinx.dataframe.api.Update.UpdateSelectingOptions]
+ * for all the selecting options.
+ * ### This Update Overload
+ * Select or express columns using the [Columns Selection DSL][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl].
+ * (Any (combination of) [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+ *
+ * This DSL is initiated by a [Columns Selector][org.jetbrains.kotlinx.dataframe.ColumnsSelector] lambda,
+ * which operates in the context of the [Columns Selection DSL][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl] and
+ * expects you to return a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn] or [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] (so, a [ColumnsResolver][org.jetbrains.kotlinx.dataframe.columns.ColumnsResolver]).
+ * This is an entity formed by calling any (combination) of the functions
+ * in the DSL that is or can be resolved into one or more columns.
+ *
+ * #### NOTE:
+ * While you can use the [String API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi.StringApi] and [KProperties API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi.KPropertiesApi]
+ * in this DSL directly with any function, they are NOT valid return types for the
+ * [Columns Selector][org.jetbrains.kotlinx.dataframe.ColumnsSelector] lambda. You'd need to turn them into a [ColumnReference][org.jetbrains.kotlinx.dataframe.columns.ColumnReference] first, for instance
+ * with a function like [`col("name")`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.col].
+ *
+ * ### Check out: [Columns Selection DSL Grammar][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.DslGrammar]
+ *
+ * &nbsp;&nbsp;&nbsp;&nbsp;
+ *
+ * [See Column Selectors on the documentation website.](https://kotlin.github.io/dataframe/columnselectors.html)
+ *
+ * #### For example:
+ *
+ * `df.`[update][org.jetbrains.kotlinx.dataframe.api.update]` { length `[and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]` age }`
+ *
+ * `df.`[update][org.jetbrains.kotlinx.dataframe.api.update]`  {  `[cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`(1..5) }`
+ *
+ * `df.`[update][org.jetbrains.kotlinx.dataframe.api.update]`  {  `[colsOf][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[Double][Double]`>() }`
+ *
+ *
+ * @param [columns] The [Columns Selector][org.jetbrains.kotlinx.dataframe.ColumnsSelector] used to select the columns of this [DataFrame][org.jetbrains.kotlinx.dataframe.DataFrame] to update.
+ */
+@Interpretable("Update0")
+public fun <T, C> DataFrame<T>.update(columns: ColumnsSelector<T, C>): Update<T, C> = Update(this, null, columns)
+
+/**
+ * ## The Update Operation
+ *
+ * Returns the [DataFrame][org.jetbrains.kotlinx.dataframe.DataFrame] with changed values in some cells
+ * (column types cannot be changed).
+ *
+ * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.Update.Grammar]
+ *
+ * For more information: [See `update` on the documentation website.](https://kotlin.github.io/dataframe/update.html)
+ *
+ * &nbsp;&nbsp;&nbsp;&nbsp;
+ *
+ * The columns to update need to be selected. See [Selecting Columns][org.jetbrains.kotlinx.dataframe.api.Update.UpdateSelectingOptions]
+ * for all the selecting options.
+ * ### This Update Overload
+ * Select columns using their [column names][String]
+ * ([String API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi.StringApi]).
+ *
+ * #### For example:
+ *
+ * `df.`[update][org.jetbrains.kotlinx.dataframe.api.update]`("length", "age")`
+ *
+ * ## Optional
+ * Combine `df.`[update][org.jetbrains.kotlinx.dataframe.api.update]`(...).`[with][org.jetbrains.kotlinx.dataframe.api.Update.with]` { ... }`
+ * into `df.`[update][org.jetbrains.kotlinx.dataframe.api.update]`(...) { ... }`
+ * @param [columns] The [Strings][String] corresponding to the names of columns belonging to this [DataFrame][org.jetbrains.kotlinx.dataframe.DataFrame] to update.
+ */
+public fun <T> DataFrame<T>.update(vararg columns: String): Update<T, Any?> = update { columns.toColumnSet() }
+
+/**
+ * ## The Update Operation
+ *
+ * Returns the [DataFrame][org.jetbrains.kotlinx.dataframe.DataFrame] with changed values in some cells
+ * (column types cannot be changed).
+ *
+ * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.Update.Grammar]
+ *
+ * For more information: [See `update` on the documentation website.](https://kotlin.github.io/dataframe/update.html)
+ *
+ * &nbsp;&nbsp;&nbsp;&nbsp;
+ *
+ * The columns to update need to be selected. See [Selecting Columns][org.jetbrains.kotlinx.dataframe.api.Update.UpdateSelectingOptions]
+ * for all the selecting options.
+ * ### This Update Overload
+ * Select columns using [KProperties][KProperty] ([KProperties API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi.KPropertiesApi]).
+ *
+ * #### For example:
+ * ```kotlin
+ * data class Person(val length: Double, val age: Double)
+ * ```
+ *
+ * `df.`[update][org.jetbrains.kotlinx.dataframe.api.update]`(Person::length, Person::age)`
+ *
+ * ## Optional
+ * Combine `df.`[update][org.jetbrains.kotlinx.dataframe.api.update]`(...).`[with][org.jetbrains.kotlinx.dataframe.api.Update.with]` { ... }`
+ * into `df.`[update][org.jetbrains.kotlinx.dataframe.api.update]`(...) { ... }`
+ * @param [columns] The [KProperties][KProperty] corresponding to columns of this [DataFrame][org.jetbrains.kotlinx.dataframe.DataFrame] to update.
+ */
+public fun <T, C> DataFrame<T>.update(vararg columns: KProperty<C>): Update<T, C> = update { columns.toColumnSet() }
+
+/**
+ * ## The Update Operation
+ *
+ * Returns the [DataFrame][org.jetbrains.kotlinx.dataframe.DataFrame] with changed values in some cells
+ * (column types cannot be changed).
+ *
+ * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.Update.Grammar]
+ *
+ * For more information: [See `update` on the documentation website.](https://kotlin.github.io/dataframe/update.html)
+ *
+ * &nbsp;&nbsp;&nbsp;&nbsp;
+ *
+ * The columns to update need to be selected. See [Selecting Columns][org.jetbrains.kotlinx.dataframe.api.Update.UpdateSelectingOptions]
+ * for all the selecting options.
+ * ### This Update Overload
+ * Select columns using [column accessors][org.jetbrains.kotlinx.dataframe.columns.ColumnReference]
+ * ([Column Accessors API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi.ColumnAccessorsApi]).
+ *
+ * #### For example:
+ *
+ * `val length by `[column][org.jetbrains.kotlinx.dataframe.api.column]`<`[Double][Double]`>()`
+ *
+ * `val age by `[column][org.jetbrains.kotlinx.dataframe.api.column]`<`[Double][Double]`>()`
+ *
+ * `df.`[update][org.jetbrains.kotlinx.dataframe.api.update]`(length, age)`
+ *
+ * ## Optional
+ * Combine `df.`[update][org.jetbrains.kotlinx.dataframe.api.update]`(...).`[with][org.jetbrains.kotlinx.dataframe.api.Update.with]` { ... }`
+ * into `df.`[update][org.jetbrains.kotlinx.dataframe.api.update]`(...) { ... }`
+ * @param [columns] The [Column References][org.jetbrains.kotlinx.dataframe.columns.ColumnReference] of this [DataFrame][org.jetbrains.kotlinx.dataframe.DataFrame] to update.
+ */
+public fun <T, C> DataFrame<T>.update(vararg columns: ColumnReference<C>): Update<T, C> =
+    update { columns.toColumnSet() }
+
+// endregion
+
+/** ## Where
+ * Filter or find rows to operate on after [selecting columns][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns] using a
+ * [row value filter][org.jetbrains.kotlinx.dataframe.RowValueFilter].
+ *
+ * For example:
+ *
+ * `df.`[update][update]` { length }.`[where][where]` { it > 10.0 }`
+ *
+ * `df.`[update][update]` { `[cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`(1..5) }.`[where][where]` { `[index][org.jetbrains.kotlinx.dataframe.index]`() > 4 && city != "Paris" }`
+ *
+ *
+ *
+ *
+ * @param [predicate] The [row value filter][RowValueFilter] to select the rows to update.
+ */
+public fun <T, C> Update<T, C>.where(predicate: RowValueFilter<T, C>): Update<T, C> =
+    Update(df = df, filter = filter and predicate, columns = columns)
+
+/**
+ * ## At
+ * Only update the columns at certain given [row indices][org.jetbrains.kotlinx.dataframe.api.CommonUpdateAtFunctionDoc.RowIndicesParam]:
+ *
+ * Either a [Collection]<[Int]>, an [IntRange], or just `vararg` indices.
+ *
+ * For example:
+ *
+ * `df.`[update][org.jetbrains.kotlinx.dataframe.api.update]` { city }.`[at][org.jetbrains.kotlinx.dataframe.api.at]`(5..10).`[with][org.jetbrains.kotlinx.dataframe.api.with]` { "Paris" }`
+ *
+ * `df.`[update][org.jetbrains.kotlinx.dataframe.api.update]` { name }.`[at][org.jetbrains.kotlinx.dataframe.api.at]`(1, 2, 3, 4).`[with][org.jetbrains.kotlinx.dataframe.api.with]` { "Empty" }`
+ *
+ * ### This At Overload
+ *
+ * Provide a [Collection]<[Int]> of row indices to update.
+ *
+ * @param [rowIndices] The indices of the rows to update. Either a [Collection]<[Int]>, an [IntRange], or just `vararg` indices.
+ */
+public fun <T, C> Update<T, C>.at(rowIndices: Collection<Int>): Update<T, C> = where { index in rowIndices }
+
+/**
+ * ## At
+ * Only update the columns at certain given [row indices][org.jetbrains.kotlinx.dataframe.api.CommonUpdateAtFunctionDoc.RowIndicesParam]:
+ *
+ * Either a [Collection]<[Int]>, an [IntRange], or just `vararg` indices.
+ *
+ * For example:
+ *
+ * `df.`[update][org.jetbrains.kotlinx.dataframe.api.update]` { city }.`[at][org.jetbrains.kotlinx.dataframe.api.at]`(5..10).`[with][org.jetbrains.kotlinx.dataframe.api.with]` { "Paris" }`
+ *
+ * `df.`[update][org.jetbrains.kotlinx.dataframe.api.update]` { name }.`[at][org.jetbrains.kotlinx.dataframe.api.at]`(1, 2, 3, 4).`[with][org.jetbrains.kotlinx.dataframe.api.with]` { "Empty" }`
+ *
+ * ### This At Overload
+ *
+ * Provide a `vararg` of [Ints][Int] of row indices to update.
+ *
+ * @param [rowIndices] The indices of the rows to update. Either a [Collection]<[Int]>, an [IntRange], or just `vararg` indices.
+ */
+public fun <T, C> Update<T, C>.at(vararg rowIndices: Int): Update<T, C> = at(rowIndices.toSet())
+
+/**
+ * ## At
+ * Only update the columns at certain given [row indices][org.jetbrains.kotlinx.dataframe.api.CommonUpdateAtFunctionDoc.RowIndicesParam]:
+ *
+ * Either a [Collection]<[Int]>, an [IntRange], or just `vararg` indices.
+ *
+ * For example:
+ *
+ * `df.`[update][org.jetbrains.kotlinx.dataframe.api.update]` { city }.`[at][org.jetbrains.kotlinx.dataframe.api.at]`(5..10).`[with][org.jetbrains.kotlinx.dataframe.api.with]` { "Paris" }`
+ *
+ * `df.`[update][org.jetbrains.kotlinx.dataframe.api.update]` { name }.`[at][org.jetbrains.kotlinx.dataframe.api.at]`(1, 2, 3, 4).`[with][org.jetbrains.kotlinx.dataframe.api.with]` { "Empty" }`
+ *
+ * ### This At Overload
+ *
+ * Provide an [IntRange] of row indices to update.
+ *
+ * @param [rowRange] The indices of the rows to update. Either a [Collection]<[Int]>, an [IntRange], or just `vararg` indices.
+ */
+public fun <T, C> Update<T, C>.at(rowRange: IntRange): Update<T, C> = where { index in rowRange }
+
+/** ## Per Row Col
+ * Provide a new value for every selected cell given both its row and column using a [row-column expression][org.jetbrains.kotlinx.dataframe.RowColumnExpression].
+ *
+ * For example:
+ *
+ * `df.`[update][update]` { age }.`[perRowCol][perRowCol]` { row, col ->`
+ *
+ * &nbsp;&nbsp;&nbsp;&nbsp;`row.age / col.`[mean][org.jetbrains.kotlinx.dataframe.DataColumn.mean]`(skipNA = true)`
+ *
+ * `}`
+ *
+ *
+ *
+ *
+ * ## See Also
+ *  - [Update with][org.jetbrains.kotlinx.dataframe.api.Update.with] to provide a new value for every selected cell giving its row.
+ *  - [Update per col][org.jetbrains.kotlinx.dataframe.api.Update.perCol] to provide a new value for every selected cell giving its column.
+ * @param [expression] The [Row Column Expression][org.jetbrains.kotlinx.dataframe.documentation.ExpressionsGivenRowAndColumn.RowColumnExpression] to provide a new value for every selected cell giving its row and column.
+ */
+public fun <T, C> Update<T, C>.perRowCol(expression: RowColumnExpression<T, C, C>): DataFrame<T> =
+    updateImpl { row, column, _ -> expression(row, column) }
+
+/**
+ * ## Update Expression
+ * @see ExpressionsGivenRow.RowValueExpression.WithExample
+ * @see ExpressionsGivenRow.AddDataRowNote
+ */
+public typealias UpdateExpression<T, C, R> = AddDataRow<T>.(C) -> R
+
+/** ## With
+ * Provide a new value for every selected cell given its row and its previous value using a
+ * [row value expression][org.jetbrains.kotlinx.dataframe.RowValueExpression].
+ *
+ * For example:
+ *
+ * `df.`[update][update]` { city }.`[with][with]` { name.firstName + " from " + it }`
+ *
+ * `df.`[update][update]` { city }.`[with][with]` { it.uppercase() }`
+ *
+ *
+ *
+ * ## Note
+ * [update with][org.jetbrains.kotlinx.dataframe.api.Update.with]- and [add][org.jetbrains.kotlinx.dataframe.api.add]-like expressions use [AddDataRow][org.jetbrains.kotlinx.dataframe.api.AddDataRow] instead of [DataRow][org.jetbrains.kotlinx.dataframe.DataRow] as the DSL's receiver type.
+ * This is an extension to [RowValueExpression][org.jetbrains.kotlinx.dataframe.RowValueExpression] and
+ * [RowExpression][org.jetbrains.kotlinx.dataframe.RowExpression] that provides access to
+ * the modified/generated value of the preceding row ([AddDataRow.newValue][org.jetbrains.kotlinx.dataframe.api.AddDataRow.newValue]).
+ * ## See Also
+ * - [Update per col][org.jetbrains.kotlinx.dataframe.api.Update.perCol] to provide a new value for every selected cell giving its column.
+ * - [Update per row col][org.jetbrains.kotlinx.dataframe.api.Update.perRowCol] to provide a new value for every selected cell giving its row and column.
+ * @param [expression] The [Row Value Expression][org.jetbrains.kotlinx.dataframe.documentation.ExpressionsGivenRow.RowValueExpression.WithExample] to update the rows with.
+ */
+@Refine
+@Interpretable("UpdateWith0")
+public fun <T, C, R : C?> Update<T, C>.with(expression: UpdateExpression<T, C, R>): DataFrame<T> =
+    updateImpl { row, _, value ->
+        expression(row, value)
+    }
+
+/** ## As Frame
+ *
+ * Updates selected [column group][ColumnGroup] as a [DataFrame] with the given [expression].
+ *
+ * Provide a new value for every selected data frame using a [dataframe expression][org.jetbrains.kotlinx.dataframe.DataFrameExpression].
+ *
+ * For example:
+ *
+ * `df.`[update][update]` { name }.`[asFrame][asFrame]` { `[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { lastName } }`
+ *
+ * @param [expression] The [Data Frame Expression][org.jetbrains.kotlinx.dataframe.documentation.ExpressionsGivenDataFrame.DataFrameExpression] to replace the selected column group with.
+ */
+public fun <T, C, R> Update<T, DataRow<C>>.asFrame(expression: DataFrameExpression<C, DataFrame<R>>): DataFrame<T> =
+    asFrameImpl(expression)
+
+/**
+ * ## Per Col
+ *
+ * Per Col can be used for two different types of operations:
+ *  - Provide a new value for every selected cell given its column using a [column expression][org.jetbrains.kotlinx.dataframe.ColumnExpression].
+ *  - Provide a new value for every selected cell per column using a [Map][Map]`<`[colName: String][String]`, value: C>`
+ *  or [DataRow][org.jetbrains.kotlinx.dataframe.DataRow] as Map.
+ *
+ * ### See Also
+ *  - [Update with][org.jetbrains.kotlinx.dataframe.api.Update.with] to provide a new value for every selected cell giving its row.
+ *  - [Update per row col][org.jetbrains.kotlinx.dataframe.api.Update.perRowCol] to provide a new value for every selected cell giving its row and column.
+ * ### This Per Col Overload
+ * Provide a new value for every selected cell per column using a [Map][Map]`<`[colName: String][String]`, value: C>`
+ *  or [DataRow][org.jetbrains.kotlinx.dataframe.DataRow] as Map.
+ *
+ * For example:
+ *
+ * `val defaults = `[mapOf][mapOf]`("name" to "Empty", "age" to 0)`
+ *
+ * `df.`[update][org.jetbrains.kotlinx.dataframe.api.update]` { name and age }.`[where][org.jetbrains.kotlinx.dataframe.api.Update.where]` { ... }.`[perCol][org.jetbrains.kotlinx.dataframe.api.perCol]`(defaults)`
+ *
+ * @throws [IllegalArgumentException] if a value for a selected cell's column is not defined in [values].
+ *
+ *
+ * @param [values] The [Map]<[String], Value> to provide a new value for every selected cell.
+ *   For each selected column, there must be a value in the map with the same name.
+ */
+public fun <T, C> Update<T, C>.perCol(values: Map<String, C>): DataFrame<T> =
+    updateWithValuePerColumnImpl {
+        values[it.name()] ?: throw IllegalArgumentException("Update value for column ${it.name()} is not defined")
+    }
+
+/**
+ * ## Per Col
+ *
+ * Per Col can be used for two different types of operations:
+ *  - Provide a new value for every selected cell given its column using a [column expression][org.jetbrains.kotlinx.dataframe.ColumnExpression].
+ *  - Provide a new value for every selected cell per column using a [Map][Map]`<`[colName: String][String]`, value: C>`
+ *  or [DataRow][org.jetbrains.kotlinx.dataframe.DataRow] as Map.
+ *
+ * ### See Also
+ *  - [Update with][org.jetbrains.kotlinx.dataframe.api.Update.with] to provide a new value for every selected cell giving its row.
+ *  - [Update per row col][org.jetbrains.kotlinx.dataframe.api.Update.perRowCol] to provide a new value for every selected cell giving its row and column.
+ * ### This Per Col Overload
+ * Provide a new value for every selected cell per column using a [Map][Map]`<`[colName: String][String]`, value: C>`
+ *  or [DataRow][org.jetbrains.kotlinx.dataframe.DataRow] as Map.
+ *
+ * For example:
+ *
+ * `val defaults = df.`[getRows][DataFrame.getRows]`(`[listOf][listOf]`(0))`
+ *
+ * &nbsp;&nbsp;&nbsp;&nbsp;`.`[update][update]` { name }.`[with][Update.with]` { "Empty" }`
+ *
+ * &nbsp;&nbsp;&nbsp;&nbsp;`.`[update][update]` { age }.`[with][Update.with]` { 0 }`
+ *
+ * &nbsp;&nbsp;&nbsp;&nbsp;`.first()`
+ *
+ * `df.`[update][org.jetbrains.kotlinx.dataframe.api.update]` { name and age }.`[where][org.jetbrains.kotlinx.dataframe.api.Update.where]` { ... }.`[perCol][org.jetbrains.kotlinx.dataframe.api.perCol]`(defaults)`
+ *
+ * @throws [IllegalArgumentException] if a value for a selected cell's column is not defined in [values].
+ *
+ *
+ * @param [values] The [DataRow] to provide a new value for every selected cell.
+ */
+public fun <T, C> Update<T, C>.perCol(values: AnyRow): DataFrame<T> = perCol(values.toMap() as Map<String, C>)
+
+/**
+ * ## Per Col
+ *
+ * Per Col can be used for two different types of operations:
+ *  - Provide a new value for every selected cell given its column using a [column expression][org.jetbrains.kotlinx.dataframe.ColumnExpression].
+ *  - Provide a new value for every selected cell per column using a [Map][Map]`<`[colName: String][String]`, value: C>`
+ *  or [DataRow][org.jetbrains.kotlinx.dataframe.DataRow] as Map.
+ *
+ * ### See Also
+ *  - [Update with][org.jetbrains.kotlinx.dataframe.api.Update.with] to provide a new value for every selected cell giving its row.
+ *  - [Update per row col][org.jetbrains.kotlinx.dataframe.api.Update.perRowCol] to provide a new value for every selected cell giving its row and column.
+ * ### This Per Col Overload
+ * Provide a new value for every selected cell given its column using a [column expression][org.jetbrains.kotlinx.dataframe.ColumnExpression].
+ *
+ * For example:
+ *
+ * `df.`[update][update]` { age }.`[perCol][perCol]` { `[mean][org.jetbrains.kotlinx.dataframe.DataColumn.mean]`(skipNA = true) }`
+ *
+ * `df.`[update][update]` { age }.`[perCol][perCol]` { `[count][org.jetbrains.kotlinx.dataframe.DataColumn.count]` { it > 10 } }`
+ *
+ *
+ *
+ * @param [valueSelector] The [Column Expression][org.jetbrains.kotlinx.dataframe.documentation.ExpressionsGivenColumn.ColumnExpression] to provide a new value for every selected cell giving its column.
+ */
+public fun <T, C> Update<T, C>.perCol(valueSelector: ColumnExpression<C, C>): DataFrame<T> =
+    updateWithValuePerColumnImpl(valueSelector)
+
+/** Chains up two row value filters together. */
+internal infix fun <T, C> RowValueFilter<T, C>?.and(other: RowValueFilter<T, C>): RowValueFilter<T, C> {
+    if (this == null) return other
+    val thisExp = this
+    return { thisExp(this, it) && other(this, it) }
+}
+
+/** ## Not Null
+ *
+ * Selects only the rows where the values in the selected columns are not null.
+ *
+ * Shorthand for: [update][org.jetbrains.kotlinx.dataframe.api.update]` { ... }.`[where][org.jetbrains.kotlinx.dataframe.api.Update.where]` { it != null }`
+ *
+ * For example:
+ *
+ * `df.`[update][org.jetbrains.kotlinx.dataframe.api.update]`  {  `[colsOf][org.jetbrains.kotlinx.dataframe.api.colsOf]`<`[Number][Number]`?>() }.`[notNull][org.jetbrains.kotlinx.dataframe.api.notNull]`().`[perCol][org.jetbrains.kotlinx.dataframe.api.Update.perCol]`  {  `[mean][org.jetbrains.kotlinx.dataframe.api.mean]`() }`
+ *
+ * ### Optional
+ * Provide an [expression] to update the rows with.
+ * This combines [with][org.jetbrains.kotlinx.dataframe.api.Update.with] with [notNull][org.jetbrains.kotlinx.dataframe.api.notNull].
+ *
+ * For example:
+ *
+ * `df.`[update][org.jetbrains.kotlinx.dataframe.api.update]` { city }.`[notNull][org.jetbrains.kotlinx.dataframe.api.Update.notNull]` { it.`[toUpperCase][String.toUpperCase]`() }`
+ *
+ * @param expression Optional [Row Expression][org.jetbrains.kotlinx.dataframe.documentation.ExpressionsGivenRow.RowExpression.WithExample] to update the rows with. */
+public fun <T, C> Update<T, C?>.notNull(): Update<T, C> = where { it != null } as Update<T, C>
+
+/**
+ * ## Not Null
+ *
+ * Selects only the rows where the values in the selected columns are not null.
+ *
+ * Shorthand for: [update][update]` { ... }.`[where][Update.where]` { it != null }`
+ *
+ * For example:
+ *
+ * `df.`[update][update]`  {  `[colsOf][colsOf]`<`[Number][Number]`?>() }.`[notNull][notNull]`().`[perCol][Update.perCol]`  {  `[mean][mean]`() }`
+ *
+ * ### Optional
+ * Provide an [expression] to update the rows with.
+ * This combines [with][Update.with] with [notNull].
+ *
+ * For example:
+ *
+ * `df.`[update][update]` { city }.`[notNull][Update.notNull]` { it.`[toUpperCase][String.toUpperCase]`() }`
+ *
+ * @param expression Optional [Row Expression][org.jetbrains.kotlinx.dataframe.documentation.ExpressionsGivenRow.RowExpression.WithExample] to update the rows with.
+ */
+public fun <T, C> Update<T, C?>.notNull(expression: UpdateExpression<T, C, C>): DataFrame<T> =
+    notNull().with(expression)
+
+/**
+ * ## The Update Operation
+ *
+ * Returns the [DataFrame][org.jetbrains.kotlinx.dataframe.DataFrame] with changed values in some cells
+ * (column types cannot be changed).
+ *
+ * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.Update.Grammar]
+ *
+ * For more information: [See `update` on the documentation website.](https://kotlin.github.io/dataframe/update.html)
+ *
+ * &nbsp;&nbsp;&nbsp;&nbsp;
+ *
+ * The columns to update need to be selected. See [Selecting Columns][org.jetbrains.kotlinx.dataframe.api.Update.UpdateSelectingOptions]
+ * for all the selecting options.
+ * ### This Update Overload
+ * This overload is a combination of [update] and [with][Update.with].
+ *
+ * Select columns using [column accessors][org.jetbrains.kotlinx.dataframe.columns.ColumnReference]
+ * ([Column Accessors API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi.ColumnAccessorsApi]).
+ *
+ * Provide a new value for every selected cell given its row and its previous value using a
+ * [row value expression][org.jetbrains.kotlinx.dataframe.RowValueExpression].
+ *
+ * For example:
+ *
+ * `df.`[update][update]<code>`("city")`</code>` { name.firstName + " from " + it }`
+ *
+ * `df.`[update][update]<code>`("city")`</code>` { it.uppercase() }`
+ *
+ *
+ *
+ * @param [columns] The [Column References][org.jetbrains.kotlinx.dataframe.columns.ColumnReference] of this [DataFrame][org.jetbrains.kotlinx.dataframe.DataFrame] to update.
+ * @param [expression] The [Row Value Expression][org.jetbrains.kotlinx.dataframe.documentation.ExpressionsGivenRow.RowValueExpression.WithExample] to update the rows with.
+ */
+public fun <T, C> DataFrame<T>.update(
+    firstCol: ColumnReference<C>,
+    vararg cols: ColumnReference<C>,
+    expression: UpdateExpression<T, C, C>,
+): DataFrame<T> = update(*headPlusArray(firstCol, cols)).with(expression)
+
+/**
+ * ## The Update Operation
+ *
+ * Returns the [DataFrame][org.jetbrains.kotlinx.dataframe.DataFrame] with changed values in some cells
+ * (column types cannot be changed).
+ *
+ * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.Update.Grammar]
+ *
+ * For more information: [See `update` on the documentation website.](https://kotlin.github.io/dataframe/update.html)
+ *
+ * &nbsp;&nbsp;&nbsp;&nbsp;
+ *
+ * The columns to update need to be selected. See [Selecting Columns][org.jetbrains.kotlinx.dataframe.api.Update.UpdateSelectingOptions]
+ * for all the selecting options.
+ * ### This Update Overload
+ * This overload is a combination of [update] and [with][Update.with].
+ *
+ * Select columns using [KProperties][KProperty] ([KProperties API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi.KPropertiesApi]).
+ *
+ * Provide a new value for every selected cell given its row and its previous value using a
+ * [row value expression][org.jetbrains.kotlinx.dataframe.RowValueExpression].
+ *
+ * For example:
+ *
+ * `df.`[update][update]<code>`("city")`</code>` { name.firstName + " from " + it }`
+ *
+ * `df.`[update][update]<code>`("city")`</code>` { it.uppercase() }`
+ *
+ *
+ *
+ * @param [columns] The [KProperties][KProperty] corresponding to columns of this [DataFrame][org.jetbrains.kotlinx.dataframe.DataFrame] to update.
+ * @param [expression] The [Row Value Expression][org.jetbrains.kotlinx.dataframe.documentation.ExpressionsGivenRow.RowValueExpression.WithExample] to update the rows with.
+ */
+public fun <T, C> DataFrame<T>.update(
+    firstCol: KProperty<C>,
+    vararg cols: KProperty<C>,
+    expression: UpdateExpression<T, C, C>,
+): DataFrame<T> = update(*headPlusArray(firstCol, cols)).with(expression)
+
+/**
+ * ## The Update Operation
+ *
+ * Returns the [DataFrame][org.jetbrains.kotlinx.dataframe.DataFrame] with changed values in some cells
+ * (column types cannot be changed).
+ *
+ * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.Update.Grammar]
+ *
+ * For more information: [See `update` on the documentation website.](https://kotlin.github.io/dataframe/update.html)
+ *
+ * &nbsp;&nbsp;&nbsp;&nbsp;
+ *
+ * The columns to update need to be selected. See [Selecting Columns][org.jetbrains.kotlinx.dataframe.api.Update.UpdateSelectingOptions]
+ * for all the selecting options.
+ * ### This Update Overload
+ * This overload is a combination of [update] and [with][Update.with].
+ *
+ * Select columns using their [column names][String]
+ * ([String API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi.StringApi]).
+ *
+ * Provide a new value for every selected cell given its row and its previous value using a
+ * [row value expression][org.jetbrains.kotlinx.dataframe.RowValueExpression].
+ *
+ * For example:
+ *
+ * `df.`[update][update]<code>`("city")`</code>` { name.firstName + " from " + it }`
+ *
+ * `df.`[update][update]<code>`("city")`</code>` { it.uppercase() }`
+ *
+ *
+ *
+ * @param [columns] The [Strings][String] corresponding to the names of columns belonging to this [DataFrame][org.jetbrains.kotlinx.dataframe.DataFrame] to update.
+ * @param [expression] The [Row Value Expression][org.jetbrains.kotlinx.dataframe.documentation.ExpressionsGivenRow.RowValueExpression.WithExample] to update the rows with.
+ */
+public fun <T> DataFrame<T>.update(
+    firstCol: String,
+    vararg cols: String,
+    expression: UpdateExpression<T, Any?, Any?>,
+): DataFrame<T> = update(*headPlusArray(firstCol, cols)).with(expression)
+
+/**
+ * ## With Null
+ * Specific version of [with][org.jetbrains.kotlinx.dataframe.api.with] that simply sets the value of each selected row to `null`.
+ *
+ * For example:
+ *
+ * `df.`[update][org.jetbrains.kotlinx.dataframe.api.update]` { id }.`[where][org.jetbrains.kotlinx.dataframe.api.Update.where]` { it < 0 }.`[withNull][withNull]`()`
+ *
+ *
+ */
+public fun <T, C> Update<T, C>.withNull(): DataFrame<T> = with { null }
+
+/**
+ * ## With Zero
+ * Specific version of [with][org.jetbrains.kotlinx.dataframe.api.with] that simply sets the value of each selected row to `0`.
+ *
+ * For example:
+ *
+ * `df.`[update][org.jetbrains.kotlinx.dataframe.api.update]` { id }.`[where][org.jetbrains.kotlinx.dataframe.api.Update.where]` { it < 0 }.`[withZero][withZero]`()`
+ *
+ *
+ */
+public fun <T, C> Update<T, C>.withZero(): DataFrame<T> = updateWithValuePerColumnImpl { 0 as C }
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/uppercase.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/uppercase.kt
new file mode 100644
index 000000000..e2595534a
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/uppercase.kt
@@ -0,0 +1,9 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import org.jetbrains.kotlinx.dataframe.StringCol
+
+// region StringCol
+
+public fun StringCol.uppercase(): StringCol = map { it?.uppercase() }
+
+// endregion
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/valueCol.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/valueCol.kt
new file mode 100644
index 000000000..82a2abf91
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/valueCol.kt
@@ -0,0 +1,3081 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import org.jetbrains.kotlinx.dataframe.AnyColumnGroupAccessor
+import org.jetbrains.kotlinx.dataframe.ColumnGroupReference
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.DataRow
+import org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.Grammar
+import org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor
+import org.jetbrains.kotlinx.dataframe.columns.ColumnGroup
+import org.jetbrains.kotlinx.dataframe.columns.ColumnPath
+import org.jetbrains.kotlinx.dataframe.columns.ColumnSet
+import org.jetbrains.kotlinx.dataframe.columns.ColumnWithPath
+import org.jetbrains.kotlinx.dataframe.columns.SingleColumn
+import org.jetbrains.kotlinx.dataframe.columns.ValueColumn
+import org.jetbrains.kotlinx.dataframe.impl.columns.getAt
+import org.jetbrains.kotlinx.dataframe.impl.columns.onResolve
+import org.jetbrains.kotlinx.dataframe.impl.columns.singleImpl
+import org.jetbrains.kotlinx.dataframe.impl.columns.transformSingle
+import kotlin.reflect.KProperty
+
+// region ColumnsSelectionDsl
+
+/**
+ * ## Value Col [Columns Selection DSL][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl]
+ *
+ * See [Grammar] for all functions in this interface.
+ * @param _UNUSED [#KT-68546](https://youtrack.jetbrains.com/issue/KT-68546/Conflicting-overloads-in-non-generic-interface-K2-2.0.0)
+ */
+public interface ValueColColumnsSelectionDsl<out _UNUSED> {
+
+    /**
+     * ## Value Col Grammar
+     *
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * [(What is this notation?)][org.jetbrains.kotlinx.dataframe.documentation.DslGrammar]
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  ### Definitions:
+     *  `columnSet: `[`ColumnSet`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]`<*>`
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  `columnGroup: `[`SingleColumn`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]`<`[`DataRow`][org.jetbrains.kotlinx.dataframe.DataRow]`<*>> | `[`String`][String]`  |  `[`KProperty`][kotlin.reflect.KProperty]`<* | `[`DataRow`][org.jetbrains.kotlinx.dataframe.DataRow]`<*>> | `[`ColumnPath`][org.jetbrains.kotlinx.dataframe.columns.ColumnPath]
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  `column: `[`ColumnAccessor`][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor]`  |  `[`String`][String]`  | `[`KProperty`][kotlin.reflect.KProperty]`<*> | `[`ColumnPath`][org.jetbrains.kotlinx.dataframe.columns.ColumnPath]
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  `index: `[`Int`][Int]
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  `T: Column type`
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  ### What can be called directly in the [Columns Selection DSL][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl]:
+     *
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  [**`valueCol`**][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.valueCol]`[`**`<`**[`T`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ColumnTypeDef]**`>`**`]`**`(`**[`column`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ColumnDef]`  |  `[`index`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.IndexDef]**`)`**
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  ### What can be called on a [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]:
+     *
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  [`columnSet`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ColumnSetDef]
+     *
+     *  &nbsp;&nbsp;&nbsp;&nbsp;__`.`__[**`valueCol`**][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.valueCol]**`(`**[`index`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.IndexDef]**`)`**
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  ### What can be called on a [Column Group (reference)][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ColumnGroupDef]:
+     *
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  [`columnGroup`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ColumnGroupDef]
+     *
+     *  &nbsp;&nbsp;&nbsp;&nbsp;__`.`__[**`valueCol`**][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.valueCol]`[`**`<`**[`T`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ColumnTypeDef]**`>`**`]`**`(`**[`column`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ColumnDef]`  |  `[`index`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.IndexDef]**`)`**
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     */
+    public interface Grammar {
+
+        /** [**`valueCol`**][ColumnsSelectionDsl.valueCol] */
+        public interface PlainDslName
+
+        /** __`.`__[**`valueCol`**][ColumnsSelectionDsl.valueCol] */
+        public interface ColumnSetName
+
+        /** __`.`__[**`valueCol`**][ColumnsSelectionDsl.valueCol] */
+        public interface ColumnGroupName
+    }
+
+    /**
+     * ## Value Col
+     *
+     * Creates a [ColumnAccessor] (or [SingleColumn]) for a value column with the given argument which can be either
+     * an index ([Int]) or a reference to a column
+     * ([String], [ColumnPath], [KProperty], or [ColumnAccessor]; any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+     *
+     * This is a DSL-shorthand for [valueColumn] and can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index). In addition, extra runtime checks are in place to ensure that the column
+     * you specify is actually a value column.
+     * The function can also be called on [ColumnGroups][ColumnGroupReference] to create
+     * an accessor for a value column inside a [ColumnGroup].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     *
+     * ### Check out: [Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][DataFrame.select]`  {  `[valueCol][valueCol]`<`[String][String]`>("valueColA") }`
+     *
+     * `df.`[select][DataFrame.select]`  {  `[valueCol][valueCol]`(SomeType::valueColB) }`
+     *
+     * `df.`[select][DataFrame.select]` { myColumnGroup.`[valueCol][valueCol]`(1) }`
+     *
+     * #### Examples for this overload:
+     *
+     *
+     *
+     * To create a [ColumnAccessor] for another kind of column, take a look at the functions
+     * [col][ColumnsSelectionDsl.col],
+     * [colGroup][ColumnsSelectionDsl.colGroup],
+     * and [frameCol][ColumnsSelectionDsl.frameCol].
+     *
+     * @return A [ColumnAccessor] for the value column with the given argument if possible, else a [SingleColumn].
+     * @throws [IllegalStateException] if the column with the given argument does not exist.
+     * @throws [IllegalArgumentException] if the column with the given argument is not a value column.
+     *
+     * @see [valueColumn]
+     * @see [ColumnsSelectionDsl.colGroup]
+     * @see [ColumnsSelectionDsl.frameCol]
+     * @see [ColumnsSelectionDsl.col]
+     *
+     */
+    private interface CommonValueColDocs {
+
+        // Example argument, can be either {@include [SingleExample]} or {@include [DoubleExample]}
+        interface ExampleArg
+
+        /**
+         * `df.`[select][DataFrame.select]` { `[valueCol][valueCol]`() }`
+         */
+        interface SingleExample
+
+        /**
+         * `df.`[select][DataFrame.select]` { `[valueCol][valueCol]`() }`
+         *
+         * `df.`[select][DataFrame.select]` { `[valueCol][valueCol]`<`[String][String]`>() }`
+         */
+        interface DoubleExample
+
+        // Receiver argument for the example(s)
+        interface ReceiverArg
+
+        // Argument for the example(s)
+        interface Arg
+
+        // Optional note
+        interface Note
+
+        /** @param [C] The type of the value column. */
+        interface ValueColumnTypeParam
+    }
+
+    // region reference
+
+    /**
+     * ## Value Col
+     *
+     * Creates a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] (or [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]) for a value column with the given argument which can be either
+     * an index ([Int]) or a reference to a column
+     * ([String], [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath], [KProperty], or [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor]; any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+     *
+     * This is a DSL-shorthand for [valueColumn][org.jetbrains.kotlinx.dataframe.api.valueColumn] and can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index). In addition, extra runtime checks are in place to ensure that the column
+     * you specify is actually a value column.
+     * The function can also be called on [ColumnGroups][org.jetbrains.kotlinx.dataframe.ColumnGroupReference] to create
+     * an accessor for a value column inside a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[valueCol][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.valueCol]`<`[String][String]`>("valueColA") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[valueCol][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.valueCol]`(SomeType::valueColB) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[valueCol][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.valueCol]`(1) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { `[valueCol][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.valueCol]`(valueColumnA) }`
+     *
+     * To create a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for another kind of column, take a look at the functions
+     * [col][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.col],
+     * [colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup],
+     * and [frameCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.frameCol].
+     *
+     * @return A [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for the value column with the given argument if possible, else a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn].
+     * @throws [IllegalStateException] if the column with the given argument does not exist.
+     * @throws [IllegalArgumentException] if the column with the given argument is not a value column.
+     *
+     * @see [valueColumn]
+     * @see [ColumnsSelectionDsl.colGroup]
+     * @see [ColumnsSelectionDsl.frameCol]
+     * @see [ColumnsSelectionDsl.col]
+     *
+     *
+     *
+     * @param [col] The [ColumnAccessor] pointing to the value column.
+     * @param [C] The type of the value column.
+     */
+    private interface ValueColReferenceDocs
+
+    /**
+     * ## Value Col
+     *
+     * Creates a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] (or [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]) for a value column with the given argument which can be either
+     * an index ([Int]) or a reference to a column
+     * ([String], [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath], [KProperty], or [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor]; any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+     *
+     * This is a DSL-shorthand for [valueColumn][org.jetbrains.kotlinx.dataframe.api.valueColumn] and can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index). In addition, extra runtime checks are in place to ensure that the column
+     * you specify is actually a value column.
+     * The function can also be called on [ColumnGroups][org.jetbrains.kotlinx.dataframe.ColumnGroupReference] to create
+     * an accessor for a value column inside a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[valueCol][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.valueCol]`<`[String][String]`>("valueColA") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[valueCol][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.valueCol]`(SomeType::valueColB) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[valueCol][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.valueCol]`(1) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { `[valueCol][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.valueCol]`(valueColumnA) }`
+     *
+     * To create a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for another kind of column, take a look at the functions
+     * [col][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.col],
+     * [colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup],
+     * and [frameCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.frameCol].
+     *
+     * @return A [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for the value column with the given argument if possible, else a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn].
+     * @throws [IllegalStateException] if the column with the given argument does not exist.
+     * @throws [IllegalArgumentException] if the column with the given argument is not a value column.
+     *
+     * @see [valueColumn]
+     * @see [ColumnsSelectionDsl.colGroup]
+     * @see [ColumnsSelectionDsl.frameCol]
+     * @see [ColumnsSelectionDsl.col]
+     *
+     *
+     *
+     * @param [col] The [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] pointing to the value column.
+     * @param [C] The type of the value column.
+     */
+    public fun <C> valueCol(valueCol: ColumnAccessor<C>): ColumnAccessor<C> = valueCol.ensureIsValueColumn()
+
+    /**
+     * ## Value Col
+     *
+     * Creates a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] (or [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]) for a value column with the given argument which can be either
+     * an index ([Int]) or a reference to a column
+     * ([String], [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath], [KProperty], or [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor]; any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+     *
+     * This is a DSL-shorthand for [valueColumn][org.jetbrains.kotlinx.dataframe.api.valueColumn] and can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index). In addition, extra runtime checks are in place to ensure that the column
+     * you specify is actually a value column.
+     * The function can also be called on [ColumnGroups][org.jetbrains.kotlinx.dataframe.ColumnGroupReference] to create
+     * an accessor for a value column inside a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[valueCol][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.valueCol]`<`[String][String]`>("valueColA") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[valueCol][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.valueCol]`(SomeType::valueColB) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[valueCol][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.valueCol]`(1) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[valueCol][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.valueCol]`(valueColumnA) }`
+     *
+     * To create a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for another kind of column, take a look at the functions
+     * [col][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.col],
+     * [colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup],
+     * and [frameCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.frameCol].
+     *
+     * @return A [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for the value column with the given argument if possible, else a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn].
+     * @throws [IllegalStateException] if the column with the given argument does not exist.
+     * @throws [IllegalArgumentException] if the column with the given argument is not a value column.
+     *
+     * @see [valueColumn]
+     * @see [ColumnsSelectionDsl.colGroup]
+     * @see [ColumnsSelectionDsl.frameCol]
+     * @see [ColumnsSelectionDsl.col]
+     *
+     *
+     *
+     * @param [col] The [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] pointing to the value column.
+     * @param [C] The type of the value column.
+     */
+    public fun <C> SingleColumn<DataRow<*>>.valueCol(valueCol: ColumnAccessor<C>): SingleColumn<C> =
+        this.ensureIsColumnGroup().transformSingle {
+            val child = it.getCol(valueCol)
+                ?: throw IllegalStateException(
+                    "ValueColumn '${valueCol.path()}' not found in column group '${it.path}'",
+                )
+            child.data.ensureIsValueColumn()
+            listOf(child)
+        }.singleImpl()
+
+    /**
+     * ## Value Col
+     *
+     * Creates a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] (or [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]) for a value column with the given argument which can be either
+     * an index ([Int]) or a reference to a column
+     * ([String], [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath], [KProperty], or [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor]; any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+     *
+     * This is a DSL-shorthand for [valueColumn][org.jetbrains.kotlinx.dataframe.api.valueColumn] and can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index). In addition, extra runtime checks are in place to ensure that the column
+     * you specify is actually a value column.
+     * The function can also be called on [ColumnGroups][org.jetbrains.kotlinx.dataframe.ColumnGroupReference] to create
+     * an accessor for a value column inside a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[valueCol][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.valueCol]`<`[String][String]`>("valueColA") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[valueCol][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.valueCol]`(SomeType::valueColB) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[valueCol][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.valueCol]`(1) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[valueCol][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.valueCol]`(valueColumnA) }`
+     *
+     * To create a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for another kind of column, take a look at the functions
+     * [col][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.col],
+     * [colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup],
+     * and [frameCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.frameCol].
+     *
+     * @return A [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for the value column with the given argument if possible, else a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn].
+     * @throws [IllegalStateException] if the column with the given argument does not exist.
+     * @throws [IllegalArgumentException] if the column with the given argument is not a value column.
+     *
+     * @see [valueColumn]
+     * @see [ColumnsSelectionDsl.colGroup]
+     * @see [ColumnsSelectionDsl.frameCol]
+     * @see [ColumnsSelectionDsl.col]
+     *
+     *
+     *
+     * @param [col] The [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] pointing to the value column.
+     * @param [C] The type of the value column.
+     */
+    public fun <C> AnyColumnGroupAccessor.valueCol(valueCol: ColumnAccessor<C>): ColumnAccessor<C> =
+        this.ensureIsColumnGroup().valueColumn<C>(valueCol.path()).ensureIsValueColumn()
+
+    /**
+     * ## Value Col
+     *
+     * Creates a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] (or [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]) for a value column with the given argument which can be either
+     * an index ([Int]) or a reference to a column
+     * ([String], [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath], [KProperty], or [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor]; any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+     *
+     * This is a DSL-shorthand for [valueColumn][org.jetbrains.kotlinx.dataframe.api.valueColumn] and can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index). In addition, extra runtime checks are in place to ensure that the column
+     * you specify is actually a value column.
+     * The function can also be called on [ColumnGroups][org.jetbrains.kotlinx.dataframe.ColumnGroupReference] to create
+     * an accessor for a value column inside a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[valueCol][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.valueCol]`<`[String][String]`>("valueColA") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[valueCol][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.valueCol]`(SomeType::valueColB) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[valueCol][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.valueCol]`(1) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "myColumnGroup".`[valueCol][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.valueCol]`(valueColumnA) }`
+     *
+     * To create a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for another kind of column, take a look at the functions
+     * [col][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.col],
+     * [colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup],
+     * and [frameCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.frameCol].
+     *
+     * @return A [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for the value column with the given argument if possible, else a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn].
+     * @throws [IllegalStateException] if the column with the given argument does not exist.
+     * @throws [IllegalArgumentException] if the column with the given argument is not a value column.
+     *
+     * @see [valueColumn]
+     * @see [ColumnsSelectionDsl.colGroup]
+     * @see [ColumnsSelectionDsl.frameCol]
+     * @see [ColumnsSelectionDsl.col]
+     *
+     *
+     *
+     * @param [col] The [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] pointing to the value column.
+     * @param [C] The type of the value column.
+     */
+    public fun <C> String.valueCol(valueCol: ColumnAccessor<C>): ColumnAccessor<C> =
+        columnGroup(this).ensureIsColumnGroup().valueColumn<C>(valueCol.path()).ensureIsValueColumn()
+
+    /**
+     * ## Value Col
+     *
+     * Creates a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] (or [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]) for a value column with the given argument which can be either
+     * an index ([Int]) or a reference to a column
+     * ([String], [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath], [KProperty], or [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor]; any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+     *
+     * This is a DSL-shorthand for [valueColumn][org.jetbrains.kotlinx.dataframe.api.valueColumn] and can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index). In addition, extra runtime checks are in place to ensure that the column
+     * you specify is actually a value column.
+     * The function can also be called on [ColumnGroups][org.jetbrains.kotlinx.dataframe.ColumnGroupReference] to create
+     * an accessor for a value column inside a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[valueCol][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.valueCol]`<`[String][String]`>("valueColA") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[valueCol][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.valueCol]`(SomeType::valueColB) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[valueCol][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.valueCol]`(1) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { Type::myColumnGroup.`[valueCol][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.valueCol]`(valueColumnA) }`
+     *
+     * To create a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for another kind of column, take a look at the functions
+     * [col][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.col],
+     * [colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup],
+     * and [frameCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.frameCol].
+     *
+     * @return A [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for the value column with the given argument if possible, else a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn].
+     * @throws [IllegalStateException] if the column with the given argument does not exist.
+     * @throws [IllegalArgumentException] if the column with the given argument is not a value column.
+     *
+     * @see [valueColumn]
+     * @see [ColumnsSelectionDsl.colGroup]
+     * @see [ColumnsSelectionDsl.frameCol]
+     * @see [ColumnsSelectionDsl.col]
+     *
+     *
+     *
+     * @param [col] The [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] pointing to the value column.
+     * @param [C] The type of the value column.
+     */
+    public fun <C> KProperty<*>.valueCol(valueCol: ColumnAccessor<C>): ColumnAccessor<C> =
+        columnGroup(this).ensureIsColumnGroup().valueColumn<C>(valueCol.path()).ensureIsValueColumn()
+
+    /**
+     * ## Value Col
+     *
+     * Creates a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] (or [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]) for a value column with the given argument which can be either
+     * an index ([Int]) or a reference to a column
+     * ([String], [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath], [KProperty], or [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor]; any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+     *
+     * This is a DSL-shorthand for [valueColumn][org.jetbrains.kotlinx.dataframe.api.valueColumn] and can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index). In addition, extra runtime checks are in place to ensure that the column
+     * you specify is actually a value column.
+     * The function can also be called on [ColumnGroups][org.jetbrains.kotlinx.dataframe.ColumnGroupReference] to create
+     * an accessor for a value column inside a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[valueCol][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.valueCol]`<`[String][String]`>("valueColA") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[valueCol][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.valueCol]`(SomeType::valueColB) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[valueCol][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.valueCol]`(1) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "pathTo"["myColumnGroup"].`[valueCol][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.valueCol]`(valueColumnA) }`
+     *
+     * To create a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for another kind of column, take a look at the functions
+     * [col][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.col],
+     * [colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup],
+     * and [frameCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.frameCol].
+     *
+     * @return A [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for the value column with the given argument if possible, else a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn].
+     * @throws [IllegalStateException] if the column with the given argument does not exist.
+     * @throws [IllegalArgumentException] if the column with the given argument is not a value column.
+     *
+     * @see [valueColumn]
+     * @see [ColumnsSelectionDsl.colGroup]
+     * @see [ColumnsSelectionDsl.frameCol]
+     * @see [ColumnsSelectionDsl.col]
+     *
+     *
+     *
+     * @param [col] The [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] pointing to the value column.
+     * @param [C] The type of the value column.
+     */
+    public fun <C> ColumnPath.valueCol(valueCol: ColumnAccessor<C>): ColumnAccessor<C> =
+        columnGroup(this).ensureIsColumnGroup().valueColumn<C>(valueCol.path()).ensureIsValueColumn()
+
+    // endregion
+
+    // region name
+
+    /**
+     * ## Value Col
+     *
+     * Creates a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] (or [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]) for a value column with the given argument which can be either
+     * an index ([Int]) or a reference to a column
+     * ([String], [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath], [KProperty], or [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor]; any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+     *
+     * This is a DSL-shorthand for [valueColumn][org.jetbrains.kotlinx.dataframe.api.valueColumn] and can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index). In addition, extra runtime checks are in place to ensure that the column
+     * you specify is actually a value column.
+     * The function can also be called on [ColumnGroups][org.jetbrains.kotlinx.dataframe.ColumnGroupReference] to create
+     * an accessor for a value column inside a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[valueCol][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.valueCol]`<`[String][String]`>("valueColA") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[valueCol][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.valueCol]`(SomeType::valueColB) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[valueCol][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.valueCol]`(1) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { `[valueCol][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.valueCol]`("valueColumnName") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { `[valueCol][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.valueCol]`<`[String][String]`>("valueColumnName") }`
+     *
+     * To create a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for another kind of column, take a look at the functions
+     * [col][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.col],
+     * [colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup],
+     * and [frameCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.frameCol].
+     *
+     * @return A [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for the value column with the given argument if possible, else a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn].
+     * @throws [IllegalStateException] if the column with the given argument does not exist.
+     * @throws [IllegalArgumentException] if the column with the given argument is not a value column.
+     *
+     * @see [valueColumn]
+     * @see [ColumnsSelectionDsl.colGroup]
+     * @see [ColumnsSelectionDsl.frameCol]
+     * @see [ColumnsSelectionDsl.col]
+     *
+     *
+     *
+     * @param [name] The name of the value column.
+     */
+    private interface ValueColNameDocs
+
+    /**
+     * ## Value Col
+     *
+     * Creates a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] (or [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]) for a value column with the given argument which can be either
+     * an index ([Int]) or a reference to a column
+     * ([String], [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath], [KProperty], or [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor]; any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+     *
+     * This is a DSL-shorthand for [valueColumn][org.jetbrains.kotlinx.dataframe.api.valueColumn] and can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index). In addition, extra runtime checks are in place to ensure that the column
+     * you specify is actually a value column.
+     * The function can also be called on [ColumnGroups][org.jetbrains.kotlinx.dataframe.ColumnGroupReference] to create
+     * an accessor for a value column inside a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[valueCol][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.valueCol]`<`[String][String]`>("valueColA") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[valueCol][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.valueCol]`(SomeType::valueColB) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[valueCol][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.valueCol]`(1) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { `[valueCol][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.valueCol]`("valueColumnName") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { `[valueCol][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.valueCol]`<`[String][String]`>("valueColumnName") }`
+     *
+     * To create a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for another kind of column, take a look at the functions
+     * [col][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.col],
+     * [colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup],
+     * and [frameCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.frameCol].
+     *
+     * @return A [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for the value column with the given argument if possible, else a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn].
+     * @throws [IllegalStateException] if the column with the given argument does not exist.
+     * @throws [IllegalArgumentException] if the column with the given argument is not a value column.
+     *
+     * @see [valueColumn]
+     * @see [ColumnsSelectionDsl.colGroup]
+     * @see [ColumnsSelectionDsl.frameCol]
+     * @see [ColumnsSelectionDsl.col]
+     *
+     *
+     *
+     * @param [name] The name of the value column.
+     */
+    @Suppress("INAPPLICABLE_JVM_NAME")
+    @JvmName("valueColUnTyped")
+    public fun valueCol(name: String): ColumnAccessor<*> = valueColumn<Any?>(name).ensureIsValueColumn()
+
+    /**
+     * ## Value Col
+     *
+     * Creates a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] (or [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]) for a value column with the given argument which can be either
+     * an index ([Int]) or a reference to a column
+     * ([String], [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath], [KProperty], or [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor]; any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+     *
+     * This is a DSL-shorthand for [valueColumn][org.jetbrains.kotlinx.dataframe.api.valueColumn] and can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index). In addition, extra runtime checks are in place to ensure that the column
+     * you specify is actually a value column.
+     * The function can also be called on [ColumnGroups][org.jetbrains.kotlinx.dataframe.ColumnGroupReference] to create
+     * an accessor for a value column inside a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[valueCol][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.valueCol]`<`[String][String]`>("valueColA") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[valueCol][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.valueCol]`(SomeType::valueColB) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[valueCol][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.valueCol]`(1) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { `[valueCol][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.valueCol]`("valueColumnName") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { `[valueCol][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.valueCol]`<`[String][String]`>("valueColumnName") }`
+     *
+     * To create a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for another kind of column, take a look at the functions
+     * [col][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.col],
+     * [colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup],
+     * and [frameCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.frameCol].
+     *
+     * @return A [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for the value column with the given argument if possible, else a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn].
+     * @throws [IllegalStateException] if the column with the given argument does not exist.
+     * @throws [IllegalArgumentException] if the column with the given argument is not a value column.
+     *
+     * @see [valueColumn]
+     * @see [ColumnsSelectionDsl.colGroup]
+     * @see [ColumnsSelectionDsl.frameCol]
+     * @see [ColumnsSelectionDsl.col]
+     *
+     *
+     *
+     * @param [name] The name of the value column.
+     * @param [C] The type of the value column.
+     */
+    public fun <C> valueCol(name: String): ColumnAccessor<C> = valueColumn<C>(name).ensureIsValueColumn()
+
+    /**
+     * ## Value Col
+     *
+     * Creates a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] (or [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]) for a value column with the given argument which can be either
+     * an index ([Int]) or a reference to a column
+     * ([String], [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath], [KProperty], or [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor]; any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+     *
+     * This is a DSL-shorthand for [valueColumn][org.jetbrains.kotlinx.dataframe.api.valueColumn] and can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index). In addition, extra runtime checks are in place to ensure that the column
+     * you specify is actually a value column.
+     * The function can also be called on [ColumnGroups][org.jetbrains.kotlinx.dataframe.ColumnGroupReference] to create
+     * an accessor for a value column inside a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[valueCol][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.valueCol]`<`[String][String]`>("valueColA") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[valueCol][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.valueCol]`(SomeType::valueColB) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[valueCol][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.valueCol]`(1) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[valueCol][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.valueCol]`("valueColumnName") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[valueCol][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.valueCol]`<`[String][String]`>("valueColumnName") }`
+     *
+     * To create a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for another kind of column, take a look at the functions
+     * [col][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.col],
+     * [colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup],
+     * and [frameCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.frameCol].
+     *
+     * @return A [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for the value column with the given argument if possible, else a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn].
+     * @throws [IllegalStateException] if the column with the given argument does not exist.
+     * @throws [IllegalArgumentException] if the column with the given argument is not a value column.
+     *
+     * @see [valueColumn]
+     * @see [ColumnsSelectionDsl.colGroup]
+     * @see [ColumnsSelectionDsl.frameCol]
+     * @see [ColumnsSelectionDsl.col]
+     *
+     *
+     *
+     * @param [name] The name of the value column.
+     */
+    @Suppress("INAPPLICABLE_JVM_NAME")
+    @JvmName("valueColUnTyped")
+    public fun SingleColumn<DataRow<*>>.valueCol(name: String): SingleColumn<*> = valueCol<Any?>(name)
+
+    /**
+     * ## Value Col
+     *
+     * Creates a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] (or [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]) for a value column with the given argument which can be either
+     * an index ([Int]) or a reference to a column
+     * ([String], [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath], [KProperty], or [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor]; any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+     *
+     * This is a DSL-shorthand for [valueColumn][org.jetbrains.kotlinx.dataframe.api.valueColumn] and can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index). In addition, extra runtime checks are in place to ensure that the column
+     * you specify is actually a value column.
+     * The function can also be called on [ColumnGroups][org.jetbrains.kotlinx.dataframe.ColumnGroupReference] to create
+     * an accessor for a value column inside a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[valueCol][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.valueCol]`<`[String][String]`>("valueColA") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[valueCol][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.valueCol]`(SomeType::valueColB) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[valueCol][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.valueCol]`(1) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[valueCol][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.valueCol]`("valueColumnName") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[valueCol][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.valueCol]`<`[String][String]`>("valueColumnName") }`
+     *
+     * To create a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for another kind of column, take a look at the functions
+     * [col][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.col],
+     * [colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup],
+     * and [frameCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.frameCol].
+     *
+     * @return A [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for the value column with the given argument if possible, else a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn].
+     * @throws [IllegalStateException] if the column with the given argument does not exist.
+     * @throws [IllegalArgumentException] if the column with the given argument is not a value column.
+     *
+     * @see [valueColumn]
+     * @see [ColumnsSelectionDsl.colGroup]
+     * @see [ColumnsSelectionDsl.frameCol]
+     * @see [ColumnsSelectionDsl.col]
+     *
+     *
+     *
+     * @param [name] The name of the value column.
+     * @param [C] The type of the value column.
+     */
+    public fun <C> SingleColumn<DataRow<*>>.valueCol(name: String): SingleColumn<C> =
+        this.ensureIsColumnGroup().transformSingle {
+            val child = it.getCol(name)?.cast<C>()
+                ?: throw IllegalStateException("Value column '$name' not found in column group '${it.path}'")
+            child.data.ensureIsValueColumn()
+            listOf(child)
+        }.singleImpl()
+
+    /**
+     * ## Value Col
+     *
+     * Creates a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] (or [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]) for a value column with the given argument which can be either
+     * an index ([Int]) or a reference to a column
+     * ([String], [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath], [KProperty], or [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor]; any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+     *
+     * This is a DSL-shorthand for [valueColumn][org.jetbrains.kotlinx.dataframe.api.valueColumn] and can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index). In addition, extra runtime checks are in place to ensure that the column
+     * you specify is actually a value column.
+     * The function can also be called on [ColumnGroups][org.jetbrains.kotlinx.dataframe.ColumnGroupReference] to create
+     * an accessor for a value column inside a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[valueCol][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.valueCol]`<`[String][String]`>("valueColA") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[valueCol][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.valueCol]`(SomeType::valueColB) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[valueCol][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.valueCol]`(1) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[valueCol][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.valueCol]`("valueColumnName") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[valueCol][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.valueCol]`<`[String][String]`>("valueColumnName") }`
+     *
+     * To create a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for another kind of column, take a look at the functions
+     * [col][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.col],
+     * [colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup],
+     * and [frameCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.frameCol].
+     *
+     * @return A [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for the value column with the given argument if possible, else a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn].
+     * @throws [IllegalStateException] if the column with the given argument does not exist.
+     * @throws [IllegalArgumentException] if the column with the given argument is not a value column.
+     *
+     * @see [valueColumn]
+     * @see [ColumnsSelectionDsl.colGroup]
+     * @see [ColumnsSelectionDsl.frameCol]
+     * @see [ColumnsSelectionDsl.col]
+     *
+     *
+     *
+     * @param [name] The name of the value column.
+     */
+    @Suppress("INAPPLICABLE_JVM_NAME")
+    @JvmName("valueColUnTyped")
+    public fun AnyColumnGroupAccessor.valueCol(name: String): ColumnAccessor<*> = valueCol<Any?>(name)
+
+    /**
+     * ## Value Col
+     *
+     * Creates a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] (or [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]) for a value column with the given argument which can be either
+     * an index ([Int]) or a reference to a column
+     * ([String], [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath], [KProperty], or [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor]; any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+     *
+     * This is a DSL-shorthand for [valueColumn][org.jetbrains.kotlinx.dataframe.api.valueColumn] and can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index). In addition, extra runtime checks are in place to ensure that the column
+     * you specify is actually a value column.
+     * The function can also be called on [ColumnGroups][org.jetbrains.kotlinx.dataframe.ColumnGroupReference] to create
+     * an accessor for a value column inside a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[valueCol][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.valueCol]`<`[String][String]`>("valueColA") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[valueCol][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.valueCol]`(SomeType::valueColB) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[valueCol][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.valueCol]`(1) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[valueCol][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.valueCol]`("valueColumnName") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[valueCol][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.valueCol]`<`[String][String]`>("valueColumnName") }`
+     *
+     * To create a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for another kind of column, take a look at the functions
+     * [col][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.col],
+     * [colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup],
+     * and [frameCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.frameCol].
+     *
+     * @return A [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for the value column with the given argument if possible, else a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn].
+     * @throws [IllegalStateException] if the column with the given argument does not exist.
+     * @throws [IllegalArgumentException] if the column with the given argument is not a value column.
+     *
+     * @see [valueColumn]
+     * @see [ColumnsSelectionDsl.colGroup]
+     * @see [ColumnsSelectionDsl.frameCol]
+     * @see [ColumnsSelectionDsl.col]
+     *
+     *
+     *
+     * @param [name] The name of the value column.
+     * @param [C] The type of the value column.
+     */
+    public fun <C> AnyColumnGroupAccessor.valueCol(name: String): ColumnAccessor<C> =
+        this.ensureIsColumnGroup().valueColumn<C>(name).ensureIsValueColumn()
+
+    /**
+     * ## Value Col
+     *
+     * Creates a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] (or [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]) for a value column with the given argument which can be either
+     * an index ([Int]) or a reference to a column
+     * ([String], [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath], [KProperty], or [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor]; any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+     *
+     * This is a DSL-shorthand for [valueColumn][org.jetbrains.kotlinx.dataframe.api.valueColumn] and can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index). In addition, extra runtime checks are in place to ensure that the column
+     * you specify is actually a value column.
+     * The function can also be called on [ColumnGroups][org.jetbrains.kotlinx.dataframe.ColumnGroupReference] to create
+     * an accessor for a value column inside a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[valueCol][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.valueCol]`<`[String][String]`>("valueColA") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[valueCol][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.valueCol]`(SomeType::valueColB) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[valueCol][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.valueCol]`(1) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "myColumnGroup".`[valueCol][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.valueCol]`("valueColumnName") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "myColumnGroup".`[valueCol][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.valueCol]`<`[String][String]`>("valueColumnName") }`
+     *
+     * To create a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for another kind of column, take a look at the functions
+     * [col][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.col],
+     * [colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup],
+     * and [frameCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.frameCol].
+     *
+     * @return A [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for the value column with the given argument if possible, else a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn].
+     * @throws [IllegalStateException] if the column with the given argument does not exist.
+     * @throws [IllegalArgumentException] if the column with the given argument is not a value column.
+     *
+     * @see [valueColumn]
+     * @see [ColumnsSelectionDsl.colGroup]
+     * @see [ColumnsSelectionDsl.frameCol]
+     * @see [ColumnsSelectionDsl.col]
+     *
+     *
+     *
+     * @param [name] The name of the value column.
+     */
+    @Suppress("INAPPLICABLE_JVM_NAME")
+    @JvmName("valueColUnTyped")
+    public fun String.valueCol(name: String): ColumnAccessor<*> = valueCol<Any?>(name)
+
+    /**
+     * ## Value Col
+     *
+     * Creates a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] (or [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]) for a value column with the given argument which can be either
+     * an index ([Int]) or a reference to a column
+     * ([String], [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath], [KProperty], or [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor]; any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+     *
+     * This is a DSL-shorthand for [valueColumn][org.jetbrains.kotlinx.dataframe.api.valueColumn] and can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index). In addition, extra runtime checks are in place to ensure that the column
+     * you specify is actually a value column.
+     * The function can also be called on [ColumnGroups][org.jetbrains.kotlinx.dataframe.ColumnGroupReference] to create
+     * an accessor for a value column inside a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[valueCol][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.valueCol]`<`[String][String]`>("valueColA") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[valueCol][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.valueCol]`(SomeType::valueColB) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[valueCol][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.valueCol]`(1) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "myColumnGroup".`[valueCol][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.valueCol]`("valueColumnName") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "myColumnGroup".`[valueCol][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.valueCol]`<`[String][String]`>("valueColumnName") }`
+     *
+     * To create a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for another kind of column, take a look at the functions
+     * [col][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.col],
+     * [colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup],
+     * and [frameCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.frameCol].
+     *
+     * @return A [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for the value column with the given argument if possible, else a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn].
+     * @throws [IllegalStateException] if the column with the given argument does not exist.
+     * @throws [IllegalArgumentException] if the column with the given argument is not a value column.
+     *
+     * @see [valueColumn]
+     * @see [ColumnsSelectionDsl.colGroup]
+     * @see [ColumnsSelectionDsl.frameCol]
+     * @see [ColumnsSelectionDsl.col]
+     *
+     *
+     *
+     * @param [name] The name of the value column.
+     * @param [C] The type of the value column.
+     */
+    public fun <C> String.valueCol(name: String): ColumnAccessor<C> =
+        columnGroup(this).ensureIsColumnGroup().valueColumn<C>(name).ensureIsValueColumn()
+
+    /**
+     * ## Value Col
+     *
+     * Creates a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] (or [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]) for a value column with the given argument which can be either
+     * an index ([Int]) or a reference to a column
+     * ([String], [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath], [KProperty], or [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor]; any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+     *
+     * This is a DSL-shorthand for [valueColumn][org.jetbrains.kotlinx.dataframe.api.valueColumn] and can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index). In addition, extra runtime checks are in place to ensure that the column
+     * you specify is actually a value column.
+     * The function can also be called on [ColumnGroups][org.jetbrains.kotlinx.dataframe.ColumnGroupReference] to create
+     * an accessor for a value column inside a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[valueCol][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.valueCol]`<`[String][String]`>("valueColA") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[valueCol][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.valueCol]`(SomeType::valueColB) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[valueCol][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.valueCol]`(1) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { Type::myColumnGroup.`[valueCol][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.valueCol]`("valueColumnName") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { Type::myColumnGroup.`[valueCol][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.valueCol]`<`[String][String]`>("valueColumnName") }`
+     *
+     * To create a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for another kind of column, take a look at the functions
+     * [col][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.col],
+     * [colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup],
+     * and [frameCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.frameCol].
+     *
+     * @return A [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for the value column with the given argument if possible, else a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn].
+     * @throws [IllegalStateException] if the column with the given argument does not exist.
+     * @throws [IllegalArgumentException] if the column with the given argument is not a value column.
+     *
+     * @see [valueColumn]
+     * @see [ColumnsSelectionDsl.colGroup]
+     * @see [ColumnsSelectionDsl.frameCol]
+     * @see [ColumnsSelectionDsl.col]
+     *
+     *
+     *
+     * @param [name] The name of the value column.
+     */
+    @Suppress("INAPPLICABLE_JVM_NAME")
+    @JvmName("valueColUnTyped")
+    public fun KProperty<*>.valueCol(name: String): ColumnAccessor<*> = valueCol<Any?>(name)
+
+    /**
+     * ## Value Col
+     *
+     * Creates a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] (or [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]) for a value column with the given argument which can be either
+     * an index ([Int]) or a reference to a column
+     * ([String], [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath], [KProperty], or [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor]; any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+     *
+     * This is a DSL-shorthand for [valueColumn][org.jetbrains.kotlinx.dataframe.api.valueColumn] and can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index). In addition, extra runtime checks are in place to ensure that the column
+     * you specify is actually a value column.
+     * The function can also be called on [ColumnGroups][org.jetbrains.kotlinx.dataframe.ColumnGroupReference] to create
+     * an accessor for a value column inside a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[valueCol][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.valueCol]`<`[String][String]`>("valueColA") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[valueCol][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.valueCol]`(SomeType::valueColB) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[valueCol][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.valueCol]`(1) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { Type::myColumnGroup.`[valueCol][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.valueCol]`("valueColumnName") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { Type::myColumnGroup.`[valueCol][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.valueCol]`<`[String][String]`>("valueColumnName") }`
+     *
+     * To create a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for another kind of column, take a look at the functions
+     * [col][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.col],
+     * [colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup],
+     * and [frameCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.frameCol].
+     *
+     * @return A [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for the value column with the given argument if possible, else a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn].
+     * @throws [IllegalStateException] if the column with the given argument does not exist.
+     * @throws [IllegalArgumentException] if the column with the given argument is not a value column.
+     *
+     * @see [valueColumn]
+     * @see [ColumnsSelectionDsl.colGroup]
+     * @see [ColumnsSelectionDsl.frameCol]
+     * @see [ColumnsSelectionDsl.col]
+     *
+     *
+     *
+     * @param [name] The name of the value column.
+     * @param [C] The type of the value column.
+     */
+    public fun <C> KProperty<*>.valueCol(name: String): ColumnAccessor<C> =
+        columnGroup(this).ensureIsColumnGroup().valueColumn<C>(name).ensureIsValueColumn()
+
+    /**
+     * ## Value Col
+     *
+     * Creates a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] (or [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]) for a value column with the given argument which can be either
+     * an index ([Int]) or a reference to a column
+     * ([String], [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath], [KProperty], or [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor]; any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+     *
+     * This is a DSL-shorthand for [valueColumn][org.jetbrains.kotlinx.dataframe.api.valueColumn] and can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index). In addition, extra runtime checks are in place to ensure that the column
+     * you specify is actually a value column.
+     * The function can also be called on [ColumnGroups][org.jetbrains.kotlinx.dataframe.ColumnGroupReference] to create
+     * an accessor for a value column inside a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[valueCol][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.valueCol]`<`[String][String]`>("valueColA") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[valueCol][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.valueCol]`(SomeType::valueColB) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[valueCol][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.valueCol]`(1) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "pathTo"["myColumnGroup"].`[valueCol][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.valueCol]`("valueColumnName") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "pathTo"["myColumnGroup"].`[valueCol][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.valueCol]`<`[String][String]`>("valueColumnName") }`
+     *
+     * To create a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for another kind of column, take a look at the functions
+     * [col][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.col],
+     * [colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup],
+     * and [frameCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.frameCol].
+     *
+     * @return A [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for the value column with the given argument if possible, else a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn].
+     * @throws [IllegalStateException] if the column with the given argument does not exist.
+     * @throws [IllegalArgumentException] if the column with the given argument is not a value column.
+     *
+     * @see [valueColumn]
+     * @see [ColumnsSelectionDsl.colGroup]
+     * @see [ColumnsSelectionDsl.frameCol]
+     * @see [ColumnsSelectionDsl.col]
+     *
+     *
+     *
+     * @param [name] The name of the value column.
+     */
+    @Suppress("INAPPLICABLE_JVM_NAME")
+    @JvmName("valueColUnTyped")
+    public fun ColumnPath.valueCol(name: String): ColumnAccessor<*> = valueCol<Any?>(name)
+
+    /**
+     * ## Value Col
+     *
+     * Creates a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] (or [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]) for a value column with the given argument which can be either
+     * an index ([Int]) or a reference to a column
+     * ([String], [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath], [KProperty], or [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor]; any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+     *
+     * This is a DSL-shorthand for [valueColumn][org.jetbrains.kotlinx.dataframe.api.valueColumn] and can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index). In addition, extra runtime checks are in place to ensure that the column
+     * you specify is actually a value column.
+     * The function can also be called on [ColumnGroups][org.jetbrains.kotlinx.dataframe.ColumnGroupReference] to create
+     * an accessor for a value column inside a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[valueCol][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.valueCol]`<`[String][String]`>("valueColA") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[valueCol][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.valueCol]`(SomeType::valueColB) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[valueCol][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.valueCol]`(1) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "pathTo"["myColumnGroup"].`[valueCol][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.valueCol]`("valueColumnName") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "pathTo"["myColumnGroup"].`[valueCol][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.valueCol]`<`[String][String]`>("valueColumnName") }`
+     *
+     * To create a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for another kind of column, take a look at the functions
+     * [col][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.col],
+     * [colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup],
+     * and [frameCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.frameCol].
+     *
+     * @return A [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for the value column with the given argument if possible, else a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn].
+     * @throws [IllegalStateException] if the column with the given argument does not exist.
+     * @throws [IllegalArgumentException] if the column with the given argument is not a value column.
+     *
+     * @see [valueColumn]
+     * @see [ColumnsSelectionDsl.colGroup]
+     * @see [ColumnsSelectionDsl.frameCol]
+     * @see [ColumnsSelectionDsl.col]
+     *
+     *
+     *
+     * @param [name] The name of the value column.
+     * @param [C] The type of the value column.
+     */
+    public fun <C> ColumnPath.valueCol(name: String): ColumnAccessor<C> =
+        columnGroup(this).ensureIsColumnGroup().valueColumn<C>(name).ensureIsValueColumn()
+
+    // endregion
+
+    // region path
+
+    /**
+     * ## Value Col
+     *
+     * Creates a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] (or [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]) for a value column with the given argument which can be either
+     * an index ([Int]) or a reference to a column
+     * ([String], [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath], [KProperty], or [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor]; any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+     *
+     * This is a DSL-shorthand for [valueColumn][org.jetbrains.kotlinx.dataframe.api.valueColumn] and can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index). In addition, extra runtime checks are in place to ensure that the column
+     * you specify is actually a value column.
+     * The function can also be called on [ColumnGroups][org.jetbrains.kotlinx.dataframe.ColumnGroupReference] to create
+     * an accessor for a value column inside a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[valueCol][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.valueCol]`<`[String][String]`>("valueColA") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[valueCol][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.valueCol]`(SomeType::valueColB) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[valueCol][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.valueCol]`(1) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { `[valueCol][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.valueCol]`("pathTo"["valueColumnName"] ) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { `[valueCol][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.valueCol]`<`[String][String]`>("pathTo"["valueColumnName"] ) }`
+     *
+     * To create a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for another kind of column, take a look at the functions
+     * [col][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.col],
+     * [colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup],
+     * and [frameCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.frameCol].
+     *
+     * @return A [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for the value column with the given argument if possible, else a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn].
+     * @throws [IllegalStateException] if the column with the given argument does not exist.
+     * @throws [IllegalArgumentException] if the column with the given argument is not a value column.
+     *
+     * @see [valueColumn]
+     * @see [ColumnsSelectionDsl.colGroup]
+     * @see [ColumnsSelectionDsl.frameCol]
+     * @see [ColumnsSelectionDsl.col]
+     *
+     *
+     *
+     * @param [path] The path to the value column.
+     */
+    private interface ValueColPathDocs
+
+    /**
+     * ## Value Col
+     *
+     * Creates a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] (or [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]) for a value column with the given argument which can be either
+     * an index ([Int]) or a reference to a column
+     * ([String], [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath], [KProperty], or [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor]; any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+     *
+     * This is a DSL-shorthand for [valueColumn][org.jetbrains.kotlinx.dataframe.api.valueColumn] and can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index). In addition, extra runtime checks are in place to ensure that the column
+     * you specify is actually a value column.
+     * The function can also be called on [ColumnGroups][org.jetbrains.kotlinx.dataframe.ColumnGroupReference] to create
+     * an accessor for a value column inside a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[valueCol][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.valueCol]`<`[String][String]`>("valueColA") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[valueCol][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.valueCol]`(SomeType::valueColB) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[valueCol][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.valueCol]`(1) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { `[valueCol][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.valueCol]`("pathTo"["valueColumnName"] ) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { `[valueCol][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.valueCol]`<`[String][String]`>("pathTo"["valueColumnName"] ) }`
+     *
+     * To create a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for another kind of column, take a look at the functions
+     * [col][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.col],
+     * [colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup],
+     * and [frameCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.frameCol].
+     *
+     * @return A [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for the value column with the given argument if possible, else a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn].
+     * @throws [IllegalStateException] if the column with the given argument does not exist.
+     * @throws [IllegalArgumentException] if the column with the given argument is not a value column.
+     *
+     * @see [valueColumn]
+     * @see [ColumnsSelectionDsl.colGroup]
+     * @see [ColumnsSelectionDsl.frameCol]
+     * @see [ColumnsSelectionDsl.col]
+     *
+     *
+     *
+     * @param [path] The path to the value column.
+     */
+    @Suppress("INAPPLICABLE_JVM_NAME")
+    @JvmName("valueColUnTyped")
+    public fun valueCol(path: ColumnPath): ColumnAccessor<*> = valueColumn<Any?>(path).ensureIsValueColumn()
+
+    /**
+     * ## Value Col
+     *
+     * Creates a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] (or [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]) for a value column with the given argument which can be either
+     * an index ([Int]) or a reference to a column
+     * ([String], [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath], [KProperty], or [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor]; any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+     *
+     * This is a DSL-shorthand for [valueColumn][org.jetbrains.kotlinx.dataframe.api.valueColumn] and can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index). In addition, extra runtime checks are in place to ensure that the column
+     * you specify is actually a value column.
+     * The function can also be called on [ColumnGroups][org.jetbrains.kotlinx.dataframe.ColumnGroupReference] to create
+     * an accessor for a value column inside a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[valueCol][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.valueCol]`<`[String][String]`>("valueColA") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[valueCol][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.valueCol]`(SomeType::valueColB) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[valueCol][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.valueCol]`(1) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { `[valueCol][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.valueCol]`("pathTo"["valueColumnName"] ) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { `[valueCol][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.valueCol]`<`[String][String]`>("pathTo"["valueColumnName"] ) }`
+     *
+     * To create a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for another kind of column, take a look at the functions
+     * [col][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.col],
+     * [colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup],
+     * and [frameCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.frameCol].
+     *
+     * @return A [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for the value column with the given argument if possible, else a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn].
+     * @throws [IllegalStateException] if the column with the given argument does not exist.
+     * @throws [IllegalArgumentException] if the column with the given argument is not a value column.
+     *
+     * @see [valueColumn]
+     * @see [ColumnsSelectionDsl.colGroup]
+     * @see [ColumnsSelectionDsl.frameCol]
+     * @see [ColumnsSelectionDsl.col]
+     *
+     *
+     *
+     * @param [path] The path to the value column.
+     * @param [C] The type of the value column.
+     */
+    public fun <C> valueCol(path: ColumnPath): ColumnAccessor<C> = valueColumn<C>(path).ensureIsValueColumn()
+
+    /**
+     * ## Value Col
+     *
+     * Creates a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] (or [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]) for a value column with the given argument which can be either
+     * an index ([Int]) or a reference to a column
+     * ([String], [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath], [KProperty], or [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor]; any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+     *
+     * This is a DSL-shorthand for [valueColumn][org.jetbrains.kotlinx.dataframe.api.valueColumn] and can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index). In addition, extra runtime checks are in place to ensure that the column
+     * you specify is actually a value column.
+     * The function can also be called on [ColumnGroups][org.jetbrains.kotlinx.dataframe.ColumnGroupReference] to create
+     * an accessor for a value column inside a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[valueCol][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.valueCol]`<`[String][String]`>("valueColA") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[valueCol][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.valueCol]`(SomeType::valueColB) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[valueCol][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.valueCol]`(1) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[valueCol][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.valueCol]`("pathTo"["valueColumnName"] ) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[valueCol][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.valueCol]`<`[String][String]`>("pathTo"["valueColumnName"] ) }`
+     *
+     * To create a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for another kind of column, take a look at the functions
+     * [col][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.col],
+     * [colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup],
+     * and [frameCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.frameCol].
+     *
+     * @return A [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for the value column with the given argument if possible, else a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn].
+     * @throws [IllegalStateException] if the column with the given argument does not exist.
+     * @throws [IllegalArgumentException] if the column with the given argument is not a value column.
+     *
+     * @see [valueColumn]
+     * @see [ColumnsSelectionDsl.colGroup]
+     * @see [ColumnsSelectionDsl.frameCol]
+     * @see [ColumnsSelectionDsl.col]
+     *
+     *
+     *
+     * @param [path] The path to the value column.
+     */
+    @Suppress("INAPPLICABLE_JVM_NAME")
+    @JvmName("valueColUnTyped")
+    public fun SingleColumn<DataRow<*>>.valueCol(path: ColumnPath): SingleColumn<*> = valueCol<Any?>(path)
+
+    /**
+     * ## Value Col
+     *
+     * Creates a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] (or [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]) for a value column with the given argument which can be either
+     * an index ([Int]) or a reference to a column
+     * ([String], [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath], [KProperty], or [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor]; any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+     *
+     * This is a DSL-shorthand for [valueColumn][org.jetbrains.kotlinx.dataframe.api.valueColumn] and can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index). In addition, extra runtime checks are in place to ensure that the column
+     * you specify is actually a value column.
+     * The function can also be called on [ColumnGroups][org.jetbrains.kotlinx.dataframe.ColumnGroupReference] to create
+     * an accessor for a value column inside a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[valueCol][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.valueCol]`<`[String][String]`>("valueColA") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[valueCol][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.valueCol]`(SomeType::valueColB) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[valueCol][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.valueCol]`(1) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[valueCol][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.valueCol]`("pathTo"["valueColumnName"] ) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[valueCol][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.valueCol]`<`[String][String]`>("pathTo"["valueColumnName"] ) }`
+     *
+     * To create a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for another kind of column, take a look at the functions
+     * [col][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.col],
+     * [colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup],
+     * and [frameCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.frameCol].
+     *
+     * @return A [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for the value column with the given argument if possible, else a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn].
+     * @throws [IllegalStateException] if the column with the given argument does not exist.
+     * @throws [IllegalArgumentException] if the column with the given argument is not a value column.
+     *
+     * @see [valueColumn]
+     * @see [ColumnsSelectionDsl.colGroup]
+     * @see [ColumnsSelectionDsl.frameCol]
+     * @see [ColumnsSelectionDsl.col]
+     *
+     *
+     *
+     * @param [path] The path to the value column.
+     * @param [C] The type of the value column.
+     */
+    public fun <C> SingleColumn<DataRow<*>>.valueCol(path: ColumnPath): SingleColumn<C> =
+        this.ensureIsColumnGroup().transformSingle {
+            val child = it.getCol(path)?.cast<C>()
+                ?: throw IllegalStateException("Value column '$path' not found in column group '${it.path}'")
+            child.data.ensureIsValueColumn()
+            listOf(child)
+        }.singleImpl()
+
+    /**
+     * ## Value Col
+     *
+     * Creates a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] (or [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]) for a value column with the given argument which can be either
+     * an index ([Int]) or a reference to a column
+     * ([String], [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath], [KProperty], or [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor]; any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+     *
+     * This is a DSL-shorthand for [valueColumn][org.jetbrains.kotlinx.dataframe.api.valueColumn] and can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index). In addition, extra runtime checks are in place to ensure that the column
+     * you specify is actually a value column.
+     * The function can also be called on [ColumnGroups][org.jetbrains.kotlinx.dataframe.ColumnGroupReference] to create
+     * an accessor for a value column inside a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[valueCol][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.valueCol]`<`[String][String]`>("valueColA") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[valueCol][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.valueCol]`(SomeType::valueColB) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[valueCol][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.valueCol]`(1) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[valueCol][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.valueCol]`("pathTo"["valueColumnName"] ) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[valueCol][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.valueCol]`<`[String][String]`>("pathTo"["valueColumnName"] ) }`
+     *
+     * To create a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for another kind of column, take a look at the functions
+     * [col][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.col],
+     * [colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup],
+     * and [frameCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.frameCol].
+     *
+     * @return A [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for the value column with the given argument if possible, else a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn].
+     * @throws [IllegalStateException] if the column with the given argument does not exist.
+     * @throws [IllegalArgumentException] if the column with the given argument is not a value column.
+     *
+     * @see [valueColumn]
+     * @see [ColumnsSelectionDsl.colGroup]
+     * @see [ColumnsSelectionDsl.frameCol]
+     * @see [ColumnsSelectionDsl.col]
+     *
+     *
+     *
+     * @param [path] The path to the value column.
+     */
+    @Suppress("INAPPLICABLE_JVM_NAME")
+    @JvmName("valueColUnTyped")
+    public fun AnyColumnGroupAccessor.valueCol(path: ColumnPath): ColumnAccessor<*> = valueCol<Any?>(path)
+
+    /**
+     * ## Value Col
+     *
+     * Creates a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] (or [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]) for a value column with the given argument which can be either
+     * an index ([Int]) or a reference to a column
+     * ([String], [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath], [KProperty], or [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor]; any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+     *
+     * This is a DSL-shorthand for [valueColumn][org.jetbrains.kotlinx.dataframe.api.valueColumn] and can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index). In addition, extra runtime checks are in place to ensure that the column
+     * you specify is actually a value column.
+     * The function can also be called on [ColumnGroups][org.jetbrains.kotlinx.dataframe.ColumnGroupReference] to create
+     * an accessor for a value column inside a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[valueCol][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.valueCol]`<`[String][String]`>("valueColA") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[valueCol][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.valueCol]`(SomeType::valueColB) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[valueCol][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.valueCol]`(1) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[valueCol][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.valueCol]`("pathTo"["valueColumnName"] ) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[valueCol][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.valueCol]`<`[String][String]`>("pathTo"["valueColumnName"] ) }`
+     *
+     * To create a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for another kind of column, take a look at the functions
+     * [col][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.col],
+     * [colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup],
+     * and [frameCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.frameCol].
+     *
+     * @return A [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for the value column with the given argument if possible, else a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn].
+     * @throws [IllegalStateException] if the column with the given argument does not exist.
+     * @throws [IllegalArgumentException] if the column with the given argument is not a value column.
+     *
+     * @see [valueColumn]
+     * @see [ColumnsSelectionDsl.colGroup]
+     * @see [ColumnsSelectionDsl.frameCol]
+     * @see [ColumnsSelectionDsl.col]
+     *
+     *
+     *
+     * @param [path] The path to the value column.
+     * @param [C] The type of the value column.
+     */
+    public fun <C> AnyColumnGroupAccessor.valueCol(path: ColumnPath): ColumnAccessor<C> =
+        this.ensureIsColumnGroup().valueColumn<C>(path).ensureIsValueColumn()
+
+    /**
+     * ## Value Col
+     *
+     * Creates a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] (or [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]) for a value column with the given argument which can be either
+     * an index ([Int]) or a reference to a column
+     * ([String], [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath], [KProperty], or [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor]; any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+     *
+     * This is a DSL-shorthand for [valueColumn][org.jetbrains.kotlinx.dataframe.api.valueColumn] and can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index). In addition, extra runtime checks are in place to ensure that the column
+     * you specify is actually a value column.
+     * The function can also be called on [ColumnGroups][org.jetbrains.kotlinx.dataframe.ColumnGroupReference] to create
+     * an accessor for a value column inside a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[valueCol][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.valueCol]`<`[String][String]`>("valueColA") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[valueCol][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.valueCol]`(SomeType::valueColB) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[valueCol][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.valueCol]`(1) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "myColumnGroup".`[valueCol][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.valueCol]`("pathTo"["valueColumnName"] ) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "myColumnGroup".`[valueCol][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.valueCol]`<`[String][String]`>("pathTo"["valueColumnName"] ) }`
+     *
+     * To create a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for another kind of column, take a look at the functions
+     * [col][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.col],
+     * [colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup],
+     * and [frameCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.frameCol].
+     *
+     * @return A [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for the value column with the given argument if possible, else a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn].
+     * @throws [IllegalStateException] if the column with the given argument does not exist.
+     * @throws [IllegalArgumentException] if the column with the given argument is not a value column.
+     *
+     * @see [valueColumn]
+     * @see [ColumnsSelectionDsl.colGroup]
+     * @see [ColumnsSelectionDsl.frameCol]
+     * @see [ColumnsSelectionDsl.col]
+     *
+     *
+     *
+     * @param [path] The path to the value column.
+     */
+    @Suppress("INAPPLICABLE_JVM_NAME")
+    @JvmName("valueColUnTyped")
+    public fun String.valueCol(path: ColumnPath): ColumnAccessor<*> = valueCol<Any?>(path)
+
+    /**
+     * ## Value Col
+     *
+     * Creates a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] (or [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]) for a value column with the given argument which can be either
+     * an index ([Int]) or a reference to a column
+     * ([String], [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath], [KProperty], or [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor]; any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+     *
+     * This is a DSL-shorthand for [valueColumn][org.jetbrains.kotlinx.dataframe.api.valueColumn] and can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index). In addition, extra runtime checks are in place to ensure that the column
+     * you specify is actually a value column.
+     * The function can also be called on [ColumnGroups][org.jetbrains.kotlinx.dataframe.ColumnGroupReference] to create
+     * an accessor for a value column inside a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[valueCol][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.valueCol]`<`[String][String]`>("valueColA") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[valueCol][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.valueCol]`(SomeType::valueColB) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[valueCol][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.valueCol]`(1) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "myColumnGroup".`[valueCol][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.valueCol]`("pathTo"["valueColumnName"] ) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "myColumnGroup".`[valueCol][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.valueCol]`<`[String][String]`>("pathTo"["valueColumnName"] ) }`
+     *
+     * To create a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for another kind of column, take a look at the functions
+     * [col][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.col],
+     * [colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup],
+     * and [frameCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.frameCol].
+     *
+     * @return A [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for the value column with the given argument if possible, else a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn].
+     * @throws [IllegalStateException] if the column with the given argument does not exist.
+     * @throws [IllegalArgumentException] if the column with the given argument is not a value column.
+     *
+     * @see [valueColumn]
+     * @see [ColumnsSelectionDsl.colGroup]
+     * @see [ColumnsSelectionDsl.frameCol]
+     * @see [ColumnsSelectionDsl.col]
+     *
+     *
+     *
+     * @param [path] The path to the value column.
+     * @param [C] The type of the value column.
+     */
+    public fun <C> String.valueCol(path: ColumnPath): ColumnAccessor<C> =
+        columnGroup(this).ensureIsColumnGroup().valueColumn<C>(path).ensureIsValueColumn()
+
+    /**
+     * ## Value Col
+     *
+     * Creates a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] (or [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]) for a value column with the given argument which can be either
+     * an index ([Int]) or a reference to a column
+     * ([String], [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath], [KProperty], or [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor]; any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+     *
+     * This is a DSL-shorthand for [valueColumn][org.jetbrains.kotlinx.dataframe.api.valueColumn] and can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index). In addition, extra runtime checks are in place to ensure that the column
+     * you specify is actually a value column.
+     * The function can also be called on [ColumnGroups][org.jetbrains.kotlinx.dataframe.ColumnGroupReference] to create
+     * an accessor for a value column inside a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[valueCol][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.valueCol]`<`[String][String]`>("valueColA") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[valueCol][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.valueCol]`(SomeType::valueColB) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[valueCol][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.valueCol]`(1) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { Type::myColumnGroup.`[valueCol][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.valueCol]`("pathTo"["valueColumnName"] ) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { Type::myColumnGroup.`[valueCol][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.valueCol]`<`[String][String]`>("pathTo"["valueColumnName"] ) }`
+     *
+     * To create a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for another kind of column, take a look at the functions
+     * [col][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.col],
+     * [colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup],
+     * and [frameCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.frameCol].
+     *
+     * @return A [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for the value column with the given argument if possible, else a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn].
+     * @throws [IllegalStateException] if the column with the given argument does not exist.
+     * @throws [IllegalArgumentException] if the column with the given argument is not a value column.
+     *
+     * @see [valueColumn]
+     * @see [ColumnsSelectionDsl.colGroup]
+     * @see [ColumnsSelectionDsl.frameCol]
+     * @see [ColumnsSelectionDsl.col]
+     *
+     *
+     *
+     * @param [path] The path to the value column.
+     */
+    @Suppress("INAPPLICABLE_JVM_NAME")
+    @JvmName("valueColUnTyped")
+    public fun KProperty<*>.valueCol(path: ColumnPath): ColumnAccessor<*> = valueCol<Any?>(path)
+
+    /**
+     * ## Value Col
+     *
+     * Creates a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] (or [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]) for a value column with the given argument which can be either
+     * an index ([Int]) or a reference to a column
+     * ([String], [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath], [KProperty], or [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor]; any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+     *
+     * This is a DSL-shorthand for [valueColumn][org.jetbrains.kotlinx.dataframe.api.valueColumn] and can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index). In addition, extra runtime checks are in place to ensure that the column
+     * you specify is actually a value column.
+     * The function can also be called on [ColumnGroups][org.jetbrains.kotlinx.dataframe.ColumnGroupReference] to create
+     * an accessor for a value column inside a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[valueCol][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.valueCol]`<`[String][String]`>("valueColA") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[valueCol][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.valueCol]`(SomeType::valueColB) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[valueCol][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.valueCol]`(1) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { Type::myColumnGroup.`[valueCol][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.valueCol]`("pathTo"["valueColumnName"] ) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { Type::myColumnGroup.`[valueCol][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.valueCol]`<`[String][String]`>("pathTo"["valueColumnName"] ) }`
+     *
+     * To create a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for another kind of column, take a look at the functions
+     * [col][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.col],
+     * [colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup],
+     * and [frameCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.frameCol].
+     *
+     * @return A [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for the value column with the given argument if possible, else a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn].
+     * @throws [IllegalStateException] if the column with the given argument does not exist.
+     * @throws [IllegalArgumentException] if the column with the given argument is not a value column.
+     *
+     * @see [valueColumn]
+     * @see [ColumnsSelectionDsl.colGroup]
+     * @see [ColumnsSelectionDsl.frameCol]
+     * @see [ColumnsSelectionDsl.col]
+     *
+     *
+     *
+     * @param [path] The path to the value column.
+     * @param [C] The type of the value column.
+     */
+    public fun <C> KProperty<*>.valueCol(path: ColumnPath): ColumnAccessor<C> =
+        columnGroup(this).ensureIsColumnGroup().valueColumn<C>(path).ensureIsValueColumn()
+
+    /**
+     * ## Value Col
+     *
+     * Creates a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] (or [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]) for a value column with the given argument which can be either
+     * an index ([Int]) or a reference to a column
+     * ([String], [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath], [KProperty], or [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor]; any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+     *
+     * This is a DSL-shorthand for [valueColumn][org.jetbrains.kotlinx.dataframe.api.valueColumn] and can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index). In addition, extra runtime checks are in place to ensure that the column
+     * you specify is actually a value column.
+     * The function can also be called on [ColumnGroups][org.jetbrains.kotlinx.dataframe.ColumnGroupReference] to create
+     * an accessor for a value column inside a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[valueCol][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.valueCol]`<`[String][String]`>("valueColA") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[valueCol][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.valueCol]`(SomeType::valueColB) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[valueCol][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.valueCol]`(1) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "pathTo"["myColumnGroup"].`[valueCol][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.valueCol]`("pathTo"["valueColumnName"] ) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "pathTo"["myColumnGroup"].`[valueCol][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.valueCol]`<`[String][String]`>("pathTo"["valueColumnName"] ) }`
+     *
+     * To create a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for another kind of column, take a look at the functions
+     * [col][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.col],
+     * [colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup],
+     * and [frameCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.frameCol].
+     *
+     * @return A [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for the value column with the given argument if possible, else a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn].
+     * @throws [IllegalStateException] if the column with the given argument does not exist.
+     * @throws [IllegalArgumentException] if the column with the given argument is not a value column.
+     *
+     * @see [valueColumn]
+     * @see [ColumnsSelectionDsl.colGroup]
+     * @see [ColumnsSelectionDsl.frameCol]
+     * @see [ColumnsSelectionDsl.col]
+     *
+     *
+     *
+     * @param [path] The path to the value column.
+     */
+    @Suppress("INAPPLICABLE_JVM_NAME")
+    @JvmName("valueColUnTyped")
+    public fun ColumnPath.valueCol(path: ColumnPath): ColumnAccessor<*> = valueCol<Any?>(path)
+
+    /**
+     * ## Value Col
+     *
+     * Creates a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] (or [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]) for a value column with the given argument which can be either
+     * an index ([Int]) or a reference to a column
+     * ([String], [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath], [KProperty], or [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor]; any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+     *
+     * This is a DSL-shorthand for [valueColumn][org.jetbrains.kotlinx.dataframe.api.valueColumn] and can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index). In addition, extra runtime checks are in place to ensure that the column
+     * you specify is actually a value column.
+     * The function can also be called on [ColumnGroups][org.jetbrains.kotlinx.dataframe.ColumnGroupReference] to create
+     * an accessor for a value column inside a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[valueCol][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.valueCol]`<`[String][String]`>("valueColA") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[valueCol][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.valueCol]`(SomeType::valueColB) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[valueCol][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.valueCol]`(1) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "pathTo"["myColumnGroup"].`[valueCol][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.valueCol]`("pathTo"["valueColumnName"] ) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "pathTo"["myColumnGroup"].`[valueCol][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.valueCol]`<`[String][String]`>("pathTo"["valueColumnName"] ) }`
+     *
+     * To create a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for another kind of column, take a look at the functions
+     * [col][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.col],
+     * [colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup],
+     * and [frameCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.frameCol].
+     *
+     * @return A [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for the value column with the given argument if possible, else a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn].
+     * @throws [IllegalStateException] if the column with the given argument does not exist.
+     * @throws [IllegalArgumentException] if the column with the given argument is not a value column.
+     *
+     * @see [valueColumn]
+     * @see [ColumnsSelectionDsl.colGroup]
+     * @see [ColumnsSelectionDsl.frameCol]
+     * @see [ColumnsSelectionDsl.col]
+     *
+     *
+     *
+     * @param [path] The path to the value column.
+     * @param [C] The type of the value column.
+     */
+    public fun <C> ColumnPath.valueCol(path: ColumnPath): ColumnAccessor<C> =
+        columnGroup(this).ensureIsColumnGroup().valueColumn<C>(path).ensureIsValueColumn()
+
+    // endregion
+
+    // region property
+
+    /**
+     * ## Value Col
+     *
+     * Creates a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] (or [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]) for a value column with the given argument which can be either
+     * an index ([Int]) or a reference to a column
+     * ([String], [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath], [KProperty], or [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor]; any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+     *
+     * This is a DSL-shorthand for [valueColumn][org.jetbrains.kotlinx.dataframe.api.valueColumn] and can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index). In addition, extra runtime checks are in place to ensure that the column
+     * you specify is actually a value column.
+     * The function can also be called on [ColumnGroups][org.jetbrains.kotlinx.dataframe.ColumnGroupReference] to create
+     * an accessor for a value column inside a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[valueCol][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.valueCol]`<`[String][String]`>("valueColA") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[valueCol][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.valueCol]`(SomeType::valueColB) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[valueCol][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.valueCol]`(1) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { `[valueCol][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.valueCol]`(Type::valueColumnA) }`
+     *
+     * To create a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for another kind of column, take a look at the functions
+     * [col][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.col],
+     * [colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup],
+     * and [frameCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.frameCol].
+     *
+     * @return A [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for the value column with the given argument if possible, else a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn].
+     * @throws [IllegalStateException] if the column with the given argument does not exist.
+     * @throws [IllegalArgumentException] if the column with the given argument is not a value column.
+     *
+     * @see [valueColumn]
+     * @see [ColumnsSelectionDsl.colGroup]
+     * @see [ColumnsSelectionDsl.frameCol]
+     * @see [ColumnsSelectionDsl.col]
+     *
+     *
+     *
+     * @param [property] The [KProperty] reference to the value column.
+     * @param [C] The type of the value column.
+     */
+    private interface ValueColKPropertyDocs
+
+    /**
+     * ## Value Col
+     *
+     * Creates a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] (or [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]) for a value column with the given argument which can be either
+     * an index ([Int]) or a reference to a column
+     * ([String], [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath], [KProperty], or [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor]; any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+     *
+     * This is a DSL-shorthand for [valueColumn][org.jetbrains.kotlinx.dataframe.api.valueColumn] and can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index). In addition, extra runtime checks are in place to ensure that the column
+     * you specify is actually a value column.
+     * The function can also be called on [ColumnGroups][org.jetbrains.kotlinx.dataframe.ColumnGroupReference] to create
+     * an accessor for a value column inside a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[valueCol][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.valueCol]`<`[String][String]`>("valueColA") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[valueCol][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.valueCol]`(SomeType::valueColB) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[valueCol][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.valueCol]`(1) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { `[valueCol][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.valueCol]`(Type::valueColumnA) }`
+     *
+     * To create a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for another kind of column, take a look at the functions
+     * [col][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.col],
+     * [colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup],
+     * and [frameCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.frameCol].
+     *
+     * @return A [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for the value column with the given argument if possible, else a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn].
+     * @throws [IllegalStateException] if the column with the given argument does not exist.
+     * @throws [IllegalArgumentException] if the column with the given argument is not a value column.
+     *
+     * @see [valueColumn]
+     * @see [ColumnsSelectionDsl.colGroup]
+     * @see [ColumnsSelectionDsl.frameCol]
+     * @see [ColumnsSelectionDsl.col]
+     *
+     *
+     *
+     * @param [property] The [KProperty] reference to the value column.
+     * @param [C] The type of the value column.
+     */
+    public fun <C> valueCol(property: KProperty<C>): SingleColumn<C> = valueColumn(property).ensureIsValueColumn()
+
+    /**
+     * ## Value Col
+     *
+     * Creates a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] (or [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]) for a value column with the given argument which can be either
+     * an index ([Int]) or a reference to a column
+     * ([String], [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath], [KProperty], or [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor]; any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+     *
+     * This is a DSL-shorthand for [valueColumn][org.jetbrains.kotlinx.dataframe.api.valueColumn] and can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index). In addition, extra runtime checks are in place to ensure that the column
+     * you specify is actually a value column.
+     * The function can also be called on [ColumnGroups][org.jetbrains.kotlinx.dataframe.ColumnGroupReference] to create
+     * an accessor for a value column inside a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[valueCol][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.valueCol]`<`[String][String]`>("valueColA") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[valueCol][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.valueCol]`(SomeType::valueColB) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[valueCol][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.valueCol]`(1) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[valueCol][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.valueCol]`(Type::valueColumnA) }`
+     *
+     * To create a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for another kind of column, take a look at the functions
+     * [col][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.col],
+     * [colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup],
+     * and [frameCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.frameCol].
+     *
+     * @return A [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for the value column with the given argument if possible, else a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn].
+     * @throws [IllegalStateException] if the column with the given argument does not exist.
+     * @throws [IllegalArgumentException] if the column with the given argument is not a value column.
+     *
+     * @see [valueColumn]
+     * @see [ColumnsSelectionDsl.colGroup]
+     * @see [ColumnsSelectionDsl.frameCol]
+     * @see [ColumnsSelectionDsl.col]
+     *
+     *
+     *
+     * @param [property] The [KProperty] reference to the value column.
+     * @param [C] The type of the value column.
+     */
+    public fun <C> SingleColumn<DataRow<*>>.valueCol(property: KProperty<C>): SingleColumn<C> =
+        valueCol<C>(property.name)
+
+    /**
+     * ## Value Col
+     *
+     * Creates a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] (or [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]) for a value column with the given argument which can be either
+     * an index ([Int]) or a reference to a column
+     * ([String], [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath], [KProperty], or [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor]; any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+     *
+     * This is a DSL-shorthand for [valueColumn][org.jetbrains.kotlinx.dataframe.api.valueColumn] and can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index). In addition, extra runtime checks are in place to ensure that the column
+     * you specify is actually a value column.
+     * The function can also be called on [ColumnGroups][org.jetbrains.kotlinx.dataframe.ColumnGroupReference] to create
+     * an accessor for a value column inside a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[valueCol][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.valueCol]`<`[String][String]`>("valueColA") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[valueCol][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.valueCol]`(SomeType::valueColB) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[valueCol][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.valueCol]`(1) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[valueCol][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.valueCol]`(Type::valueColumnA) }`
+     *
+     * To create a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for another kind of column, take a look at the functions
+     * [col][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.col],
+     * [colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup],
+     * and [frameCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.frameCol].
+     *
+     * @return A [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for the value column with the given argument if possible, else a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn].
+     * @throws [IllegalStateException] if the column with the given argument does not exist.
+     * @throws [IllegalArgumentException] if the column with the given argument is not a value column.
+     *
+     * @see [valueColumn]
+     * @see [ColumnsSelectionDsl.colGroup]
+     * @see [ColumnsSelectionDsl.frameCol]
+     * @see [ColumnsSelectionDsl.col]
+     *
+     *
+     *
+     * @param [property] The [KProperty] reference to the value column.
+     * @param [C] The type of the value column.
+     */
+    public fun <C> AnyColumnGroupAccessor.valueCol(property: KProperty<C>): ColumnAccessor<C> =
+        this.ensureIsColumnGroup().valueColumn(property).ensureIsValueColumn()
+
+    /**
+     * ## Value Col
+     *
+     * Creates a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] (or [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]) for a value column with the given argument which can be either
+     * an index ([Int]) or a reference to a column
+     * ([String], [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath], [KProperty], or [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor]; any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+     *
+     * This is a DSL-shorthand for [valueColumn][org.jetbrains.kotlinx.dataframe.api.valueColumn] and can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index). In addition, extra runtime checks are in place to ensure that the column
+     * you specify is actually a value column.
+     * The function can also be called on [ColumnGroups][org.jetbrains.kotlinx.dataframe.ColumnGroupReference] to create
+     * an accessor for a value column inside a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[valueCol][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.valueCol]`<`[String][String]`>("valueColA") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[valueCol][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.valueCol]`(SomeType::valueColB) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[valueCol][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.valueCol]`(1) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "myColumnGroup".`[valueCol][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.valueCol]`(Type::valueColumnA) }`
+     *
+     * To create a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for another kind of column, take a look at the functions
+     * [col][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.col],
+     * [colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup],
+     * and [frameCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.frameCol].
+     *
+     * @return A [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for the value column with the given argument if possible, else a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn].
+     * @throws [IllegalStateException] if the column with the given argument does not exist.
+     * @throws [IllegalArgumentException] if the column with the given argument is not a value column.
+     *
+     * @see [valueColumn]
+     * @see [ColumnsSelectionDsl.colGroup]
+     * @see [ColumnsSelectionDsl.frameCol]
+     * @see [ColumnsSelectionDsl.col]
+     *
+     *
+     *
+     * @param [property] The [KProperty] reference to the value column.
+     * @param [C] The type of the value column.
+     */
+    public fun <C> String.valueCol(property: KProperty<C>): ColumnAccessor<C> =
+        columnGroup(this).ensureIsColumnGroup().valueColumn(property).ensureIsValueColumn()
+
+    /**
+     * ## Value Col
+     *
+     * Creates a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] (or [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]) for a value column with the given argument which can be either
+     * an index ([Int]) or a reference to a column
+     * ([String], [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath], [KProperty], or [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor]; any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+     *
+     * This is a DSL-shorthand for [valueColumn][org.jetbrains.kotlinx.dataframe.api.valueColumn] and can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index). In addition, extra runtime checks are in place to ensure that the column
+     * you specify is actually a value column.
+     * The function can also be called on [ColumnGroups][org.jetbrains.kotlinx.dataframe.ColumnGroupReference] to create
+     * an accessor for a value column inside a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[valueCol][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.valueCol]`<`[String][String]`>("valueColA") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[valueCol][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.valueCol]`(SomeType::valueColB) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[valueCol][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.valueCol]`(1) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { Type::myColumnGroup.`[valueCol][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.valueCol]`(Type::valueColumnA) }`
+     *
+     * To create a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for another kind of column, take a look at the functions
+     * [col][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.col],
+     * [colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup],
+     * and [frameCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.frameCol].
+     *
+     * @return A [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for the value column with the given argument if possible, else a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn].
+     * @throws [IllegalStateException] if the column with the given argument does not exist.
+     * @throws [IllegalArgumentException] if the column with the given argument is not a value column.
+     *
+     * @see [valueColumn]
+     * @see [ColumnsSelectionDsl.colGroup]
+     * @see [ColumnsSelectionDsl.frameCol]
+     * @see [ColumnsSelectionDsl.col]
+     *
+     *
+     *
+     * @param [property] The [KProperty] reference to the value column.
+     * @param [C] The type of the value column.
+     */
+    public fun <C> KProperty<*>.valueCol(property: KProperty<C>): ColumnAccessor<C> =
+        columnGroup(this).ensureIsColumnGroup().valueColumn(property).ensureIsValueColumn()
+
+    /**
+     * ## Value Col
+     *
+     * Creates a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] (or [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]) for a value column with the given argument which can be either
+     * an index ([Int]) or a reference to a column
+     * ([String], [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath], [KProperty], or [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor]; any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+     *
+     * This is a DSL-shorthand for [valueColumn][org.jetbrains.kotlinx.dataframe.api.valueColumn] and can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index). In addition, extra runtime checks are in place to ensure that the column
+     * you specify is actually a value column.
+     * The function can also be called on [ColumnGroups][org.jetbrains.kotlinx.dataframe.ColumnGroupReference] to create
+     * an accessor for a value column inside a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[valueCol][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.valueCol]`<`[String][String]`>("valueColA") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[valueCol][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.valueCol]`(SomeType::valueColB) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[valueCol][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.valueCol]`(1) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "pathTo"["myColumnGroup"].`[valueCol][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.valueCol]`(Type::valueColumnA) }`
+     *
+     * To create a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for another kind of column, take a look at the functions
+     * [col][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.col],
+     * [colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup],
+     * and [frameCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.frameCol].
+     *
+     * @return A [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for the value column with the given argument if possible, else a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn].
+     * @throws [IllegalStateException] if the column with the given argument does not exist.
+     * @throws [IllegalArgumentException] if the column with the given argument is not a value column.
+     *
+     * @see [valueColumn]
+     * @see [ColumnsSelectionDsl.colGroup]
+     * @see [ColumnsSelectionDsl.frameCol]
+     * @see [ColumnsSelectionDsl.col]
+     *
+     *
+     *
+     * @param [property] The [KProperty] reference to the value column.
+     * @param [C] The type of the value column.
+     */
+    public fun <C> ColumnPath.valueCol(property: KProperty<C>): ColumnAccessor<C> =
+        columnGroup(this).ensureIsColumnGroup().valueColumn(property).ensureIsValueColumn()
+
+    // endregion
+
+    // region index
+
+    /**
+     * ## Value Col
+     *
+     * Creates a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] (or [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]) for a value column with the given argument which can be either
+     * an index ([Int]) or a reference to a column
+     * ([String], [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath], [KProperty], or [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor]; any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+     *
+     * This is a DSL-shorthand for [valueColumn][org.jetbrains.kotlinx.dataframe.api.valueColumn] and can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index). In addition, extra runtime checks are in place to ensure that the column
+     * you specify is actually a value column.
+     * The function can also be called on [ColumnGroups][org.jetbrains.kotlinx.dataframe.ColumnGroupReference] to create
+     * an accessor for a value column inside a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[valueCol][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.valueCol]`<`[String][String]`>("valueColA") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[valueCol][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.valueCol]`(SomeType::valueColB) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[valueCol][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.valueCol]`(1) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { `[valueCol][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.valueCol]`(0) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { `[valueCol][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.valueCol]`<`[String][String]`>(0) }`
+     *
+     * To create a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for another kind of column, take a look at the functions
+     * [col][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.col],
+     * [colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup],
+     * and [frameCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.frameCol].
+     *
+     * @return A [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for the value column with the given argument if possible, else a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn].
+     * @throws [IllegalStateException] if the column with the given argument does not exist.
+     * @throws [IllegalArgumentException] if the column with the given argument is not a value column.
+     *
+     * @see [valueColumn]
+     * @see [ColumnsSelectionDsl.colGroup]
+     * @see [ColumnsSelectionDsl.frameCol]
+     * @see [ColumnsSelectionDsl.col]
+     *
+     *
+     *
+     * @param [index] The index of the value column.
+     * @throws [IndexOutOfBoundsException] if the index is out of bounds.
+     */
+    private interface ValueColIndexDocs
+
+    /**
+     * ## Value Col
+     *
+     * Creates a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] (or [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]) for a value column with the given argument which can be either
+     * an index ([Int]) or a reference to a column
+     * ([String], [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath], [KProperty], or [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor]; any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+     *
+     * This is a DSL-shorthand for [valueColumn][org.jetbrains.kotlinx.dataframe.api.valueColumn] and can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index). In addition, extra runtime checks are in place to ensure that the column
+     * you specify is actually a value column.
+     * The function can also be called on [ColumnGroups][org.jetbrains.kotlinx.dataframe.ColumnGroupReference] to create
+     * an accessor for a value column inside a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[valueCol][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.valueCol]`<`[String][String]`>("valueColA") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[valueCol][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.valueCol]`(SomeType::valueColB) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[valueCol][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.valueCol]`(1) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { `[colsOf][ColumnsSelectionDsl.colsOf]`<`[Int][Int]`>().`[valueCol][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.valueCol]`(0) }`
+     *
+     * To create a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for another kind of column, take a look at the functions
+     * [col][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.col],
+     * [colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup],
+     * and [frameCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.frameCol].
+     *
+     * @return A [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for the value column with the given argument if possible, else a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn].
+     * @throws [IllegalStateException] if the column with the given argument does not exist.
+     * @throws [IllegalArgumentException] if the column with the given argument is not a value column.
+     *
+     * @see [valueColumn]
+     * @see [ColumnsSelectionDsl.colGroup]
+     * @see [ColumnsSelectionDsl.frameCol]
+     * @see [ColumnsSelectionDsl.col]
+     *
+     *
+     *
+     * @param [index] The index of the value column.
+     * @throws [IndexOutOfBoundsException] if the index is out of bounds.
+     * @param [C] The type of the value column.
+     *
+     */
+    public fun <C> ColumnSet<C>.valueCol(index: Int): SingleColumn<C> = getAt(index).ensureIsValueColumn()
+
+    /**
+     * ## Value Col
+     *
+     * Creates a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] (or [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]) for a value column with the given argument which can be either
+     * an index ([Int]) or a reference to a column
+     * ([String], [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath], [KProperty], or [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor]; any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+     *
+     * This is a DSL-shorthand for [valueColumn][org.jetbrains.kotlinx.dataframe.api.valueColumn] and can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index). In addition, extra runtime checks are in place to ensure that the column
+     * you specify is actually a value column.
+     * The function can also be called on [ColumnGroups][org.jetbrains.kotlinx.dataframe.ColumnGroupReference] to create
+     * an accessor for a value column inside a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[valueCol][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.valueCol]`<`[String][String]`>("valueColA") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[valueCol][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.valueCol]`(SomeType::valueColB) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[valueCol][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.valueCol]`(1) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { `[valueCol][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.valueCol]`(0) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { `[valueCol][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.valueCol]`<`[String][String]`>(0) }`
+     *
+     * To create a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for another kind of column, take a look at the functions
+     * [col][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.col],
+     * [colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup],
+     * and [frameCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.frameCol].
+     *
+     * @return A [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for the value column with the given argument if possible, else a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn].
+     * @throws [IllegalStateException] if the column with the given argument does not exist.
+     * @throws [IllegalArgumentException] if the column with the given argument is not a value column.
+     *
+     * @see [valueColumn]
+     * @see [ColumnsSelectionDsl.colGroup]
+     * @see [ColumnsSelectionDsl.frameCol]
+     * @see [ColumnsSelectionDsl.col]
+     *
+     *
+     *
+     * @param [index] The index of the value column.
+     * @throws [IndexOutOfBoundsException] if the index is out of bounds.
+     */
+    @Suppress("INAPPLICABLE_JVM_NAME")
+    @JvmName("valueColUnTyped")
+    public fun ColumnsSelectionDsl<*>.valueCol(index: Int): SingleColumn<*> = valueCol<Any?>(index)
+
+    /**
+     * ## Value Col
+     *
+     * Creates a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] (or [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]) for a value column with the given argument which can be either
+     * an index ([Int]) or a reference to a column
+     * ([String], [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath], [KProperty], or [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor]; any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+     *
+     * This is a DSL-shorthand for [valueColumn][org.jetbrains.kotlinx.dataframe.api.valueColumn] and can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index). In addition, extra runtime checks are in place to ensure that the column
+     * you specify is actually a value column.
+     * The function can also be called on [ColumnGroups][org.jetbrains.kotlinx.dataframe.ColumnGroupReference] to create
+     * an accessor for a value column inside a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[valueCol][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.valueCol]`<`[String][String]`>("valueColA") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[valueCol][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.valueCol]`(SomeType::valueColB) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[valueCol][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.valueCol]`(1) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { `[valueCol][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.valueCol]`(0) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { `[valueCol][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.valueCol]`<`[String][String]`>(0) }`
+     *
+     * To create a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for another kind of column, take a look at the functions
+     * [col][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.col],
+     * [colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup],
+     * and [frameCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.frameCol].
+     *
+     * @return A [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for the value column with the given argument if possible, else a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn].
+     * @throws [IllegalStateException] if the column with the given argument does not exist.
+     * @throws [IllegalArgumentException] if the column with the given argument is not a value column.
+     *
+     * @see [valueColumn]
+     * @see [ColumnsSelectionDsl.colGroup]
+     * @see [ColumnsSelectionDsl.frameCol]
+     * @see [ColumnsSelectionDsl.col]
+     *
+     *
+     *
+     * @param [index] The index of the value column.
+     * @throws [IndexOutOfBoundsException] if the index is out of bounds.
+     * @param [C] The type of the value column.
+     */
+    public fun <C> ColumnsSelectionDsl<*>.valueCol(index: Int): SingleColumn<C> = asSingleColumn().valueCol<C>(index)
+
+    /**
+     * ## Value Col
+     *
+     * Creates a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] (or [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]) for a value column with the given argument which can be either
+     * an index ([Int]) or a reference to a column
+     * ([String], [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath], [KProperty], or [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor]; any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+     *
+     * This is a DSL-shorthand for [valueColumn][org.jetbrains.kotlinx.dataframe.api.valueColumn] and can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index). In addition, extra runtime checks are in place to ensure that the column
+     * you specify is actually a value column.
+     * The function can also be called on [ColumnGroups][org.jetbrains.kotlinx.dataframe.ColumnGroupReference] to create
+     * an accessor for a value column inside a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[valueCol][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.valueCol]`<`[String][String]`>("valueColA") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[valueCol][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.valueCol]`(SomeType::valueColB) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[valueCol][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.valueCol]`(1) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[valueCol][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.valueCol]`(0) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[valueCol][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.valueCol]`<`[String][String]`>(0) }`
+     *
+     * To create a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for another kind of column, take a look at the functions
+     * [col][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.col],
+     * [colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup],
+     * and [frameCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.frameCol].
+     *
+     * @return A [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for the value column with the given argument if possible, else a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn].
+     * @throws [IllegalStateException] if the column with the given argument does not exist.
+     * @throws [IllegalArgumentException] if the column with the given argument is not a value column.
+     *
+     * @see [valueColumn]
+     * @see [ColumnsSelectionDsl.colGroup]
+     * @see [ColumnsSelectionDsl.frameCol]
+     * @see [ColumnsSelectionDsl.col]
+     *
+     *
+     *
+     * @param [index] The index of the value column.
+     * @throws [IndexOutOfBoundsException] if the index is out of bounds.
+     */
+    @Suppress("INAPPLICABLE_JVM_NAME")
+    @JvmName("valueColUnTyped")
+    public fun SingleColumn<DataRow<*>>.valueCol(index: Int): SingleColumn<*> = valueCol<Any?>(index)
+
+    /**
+     * ## Value Col
+     *
+     * Creates a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] (or [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]) for a value column with the given argument which can be either
+     * an index ([Int]) or a reference to a column
+     * ([String], [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath], [KProperty], or [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor]; any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+     *
+     * This is a DSL-shorthand for [valueColumn][org.jetbrains.kotlinx.dataframe.api.valueColumn] and can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index). In addition, extra runtime checks are in place to ensure that the column
+     * you specify is actually a value column.
+     * The function can also be called on [ColumnGroups][org.jetbrains.kotlinx.dataframe.ColumnGroupReference] to create
+     * an accessor for a value column inside a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[valueCol][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.valueCol]`<`[String][String]`>("valueColA") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[valueCol][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.valueCol]`(SomeType::valueColB) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[valueCol][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.valueCol]`(1) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[valueCol][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.valueCol]`(0) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[valueCol][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.valueCol]`<`[String][String]`>(0) }`
+     *
+     * To create a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for another kind of column, take a look at the functions
+     * [col][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.col],
+     * [colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup],
+     * and [frameCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.frameCol].
+     *
+     * @return A [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for the value column with the given argument if possible, else a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn].
+     * @throws [IllegalStateException] if the column with the given argument does not exist.
+     * @throws [IllegalArgumentException] if the column with the given argument is not a value column.
+     *
+     * @see [valueColumn]
+     * @see [ColumnsSelectionDsl.colGroup]
+     * @see [ColumnsSelectionDsl.frameCol]
+     * @see [ColumnsSelectionDsl.col]
+     *
+     *
+     *
+     * @param [index] The index of the value column.
+     * @throws [IndexOutOfBoundsException] if the index is out of bounds.
+     * @param [C] The type of the value column.
+     */
+    public fun <C> SingleColumn<DataRow<*>>.valueCol(index: Int): SingleColumn<C> =
+        this.ensureIsColumnGroup()
+            .allColumnsInternal()
+            .getAt(index)
+            .ensureIsValueColumn()
+            .cast()
+
+    /**
+     * ## Value Col
+     *
+     * Creates a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] (or [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]) for a value column with the given argument which can be either
+     * an index ([Int]) or a reference to a column
+     * ([String], [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath], [KProperty], or [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor]; any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+     *
+     * This is a DSL-shorthand for [valueColumn][org.jetbrains.kotlinx.dataframe.api.valueColumn] and can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index). In addition, extra runtime checks are in place to ensure that the column
+     * you specify is actually a value column.
+     * The function can also be called on [ColumnGroups][org.jetbrains.kotlinx.dataframe.ColumnGroupReference] to create
+     * an accessor for a value column inside a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[valueCol][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.valueCol]`<`[String][String]`>("valueColA") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[valueCol][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.valueCol]`(SomeType::valueColB) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[valueCol][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.valueCol]`(1) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "myColumnGroup".`[valueCol][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.valueCol]`(0) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "myColumnGroup".`[valueCol][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.valueCol]`<`[String][String]`>(0) }`
+     *
+     * To create a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for another kind of column, take a look at the functions
+     * [col][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.col],
+     * [colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup],
+     * and [frameCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.frameCol].
+     *
+     * @return A [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for the value column with the given argument if possible, else a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn].
+     * @throws [IllegalStateException] if the column with the given argument does not exist.
+     * @throws [IllegalArgumentException] if the column with the given argument is not a value column.
+     *
+     * @see [valueColumn]
+     * @see [ColumnsSelectionDsl.colGroup]
+     * @see [ColumnsSelectionDsl.frameCol]
+     * @see [ColumnsSelectionDsl.col]
+     *
+     *
+     *
+     * @param [index] The index of the value column.
+     * @throws [IndexOutOfBoundsException] if the index is out of bounds.
+     */
+    @Suppress("INAPPLICABLE_JVM_NAME")
+    @JvmName("valueColUnTyped")
+    public fun String.valueCol(index: Int): SingleColumn<*> = valueCol<Any?>(index)
+
+    /**
+     * ## Value Col
+     *
+     * Creates a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] (or [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]) for a value column with the given argument which can be either
+     * an index ([Int]) or a reference to a column
+     * ([String], [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath], [KProperty], or [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor]; any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+     *
+     * This is a DSL-shorthand for [valueColumn][org.jetbrains.kotlinx.dataframe.api.valueColumn] and can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index). In addition, extra runtime checks are in place to ensure that the column
+     * you specify is actually a value column.
+     * The function can also be called on [ColumnGroups][org.jetbrains.kotlinx.dataframe.ColumnGroupReference] to create
+     * an accessor for a value column inside a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[valueCol][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.valueCol]`<`[String][String]`>("valueColA") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[valueCol][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.valueCol]`(SomeType::valueColB) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[valueCol][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.valueCol]`(1) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "myColumnGroup".`[valueCol][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.valueCol]`(0) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "myColumnGroup".`[valueCol][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.valueCol]`<`[String][String]`>(0) }`
+     *
+     * To create a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for another kind of column, take a look at the functions
+     * [col][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.col],
+     * [colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup],
+     * and [frameCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.frameCol].
+     *
+     * @return A [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for the value column with the given argument if possible, else a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn].
+     * @throws [IllegalStateException] if the column with the given argument does not exist.
+     * @throws [IllegalArgumentException] if the column with the given argument is not a value column.
+     *
+     * @see [valueColumn]
+     * @see [ColumnsSelectionDsl.colGroup]
+     * @see [ColumnsSelectionDsl.frameCol]
+     * @see [ColumnsSelectionDsl.col]
+     *
+     *
+     *
+     * @param [index] The index of the value column.
+     * @throws [IndexOutOfBoundsException] if the index is out of bounds.
+     * @param [C] The type of the value column.
+     */
+    public fun <C> String.valueCol(index: Int): SingleColumn<C> = columnGroup(this).valueCol<C>(index)
+
+    /**
+     * ## Value Col
+     *
+     * Creates a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] (or [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]) for a value column with the given argument which can be either
+     * an index ([Int]) or a reference to a column
+     * ([String], [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath], [KProperty], or [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor]; any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+     *
+     * This is a DSL-shorthand for [valueColumn][org.jetbrains.kotlinx.dataframe.api.valueColumn] and can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index). In addition, extra runtime checks are in place to ensure that the column
+     * you specify is actually a value column.
+     * The function can also be called on [ColumnGroups][org.jetbrains.kotlinx.dataframe.ColumnGroupReference] to create
+     * an accessor for a value column inside a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[valueCol][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.valueCol]`<`[String][String]`>("valueColA") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[valueCol][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.valueCol]`(SomeType::valueColB) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[valueCol][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.valueCol]`(1) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { Type::myColumnGroup.`[valueCol][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.valueCol]`(0) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { Type::myColumnGroup.`[valueCol][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.valueCol]`<`[String][String]`>(0) }`
+     *
+     * To create a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for another kind of column, take a look at the functions
+     * [col][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.col],
+     * [colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup],
+     * and [frameCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.frameCol].
+     *
+     * @return A [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for the value column with the given argument if possible, else a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn].
+     * @throws [IllegalStateException] if the column with the given argument does not exist.
+     * @throws [IllegalArgumentException] if the column with the given argument is not a value column.
+     *
+     * @see [valueColumn]
+     * @see [ColumnsSelectionDsl.colGroup]
+     * @see [ColumnsSelectionDsl.frameCol]
+     * @see [ColumnsSelectionDsl.col]
+     *
+     *
+     *
+     * @param [index] The index of the value column.
+     * @throws [IndexOutOfBoundsException] if the index is out of bounds.
+     */
+    @Suppress("INAPPLICABLE_JVM_NAME")
+    @JvmName("valueColUnTyped")
+    public fun KProperty<*>.valueCol(index: Int): SingleColumn<*> = valueCol<Any?>(index)
+
+    /**
+     * ## Value Col
+     *
+     * Creates a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] (or [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]) for a value column with the given argument which can be either
+     * an index ([Int]) or a reference to a column
+     * ([String], [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath], [KProperty], or [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor]; any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+     *
+     * This is a DSL-shorthand for [valueColumn][org.jetbrains.kotlinx.dataframe.api.valueColumn] and can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index). In addition, extra runtime checks are in place to ensure that the column
+     * you specify is actually a value column.
+     * The function can also be called on [ColumnGroups][org.jetbrains.kotlinx.dataframe.ColumnGroupReference] to create
+     * an accessor for a value column inside a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[valueCol][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.valueCol]`<`[String][String]`>("valueColA") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[valueCol][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.valueCol]`(SomeType::valueColB) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[valueCol][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.valueCol]`(1) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { Type::myColumnGroup.`[valueCol][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.valueCol]`(0) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { Type::myColumnGroup.`[valueCol][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.valueCol]`<`[String][String]`>(0) }`
+     *
+     * To create a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for another kind of column, take a look at the functions
+     * [col][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.col],
+     * [colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup],
+     * and [frameCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.frameCol].
+     *
+     * @return A [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for the value column with the given argument if possible, else a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn].
+     * @throws [IllegalStateException] if the column with the given argument does not exist.
+     * @throws [IllegalArgumentException] if the column with the given argument is not a value column.
+     *
+     * @see [valueColumn]
+     * @see [ColumnsSelectionDsl.colGroup]
+     * @see [ColumnsSelectionDsl.frameCol]
+     * @see [ColumnsSelectionDsl.col]
+     *
+     *
+     *
+     * @param [index] The index of the value column.
+     * @throws [IndexOutOfBoundsException] if the index is out of bounds.
+     * @param [C] The type of the value column.
+     */
+    public fun <C> KProperty<*>.valueCol(index: Int): SingleColumn<C> = columnGroup(this).valueCol<C>(index)
+
+    /**
+     * ## Value Col
+     *
+     * Creates a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] (or [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]) for a value column with the given argument which can be either
+     * an index ([Int]) or a reference to a column
+     * ([String], [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath], [KProperty], or [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor]; any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+     *
+     * This is a DSL-shorthand for [valueColumn][org.jetbrains.kotlinx.dataframe.api.valueColumn] and can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index). In addition, extra runtime checks are in place to ensure that the column
+     * you specify is actually a value column.
+     * The function can also be called on [ColumnGroups][org.jetbrains.kotlinx.dataframe.ColumnGroupReference] to create
+     * an accessor for a value column inside a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[valueCol][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.valueCol]`<`[String][String]`>("valueColA") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[valueCol][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.valueCol]`(SomeType::valueColB) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[valueCol][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.valueCol]`(1) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "pathTo"["myColumnGroup"].`[valueCol][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.valueCol]`(0) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "pathTo"["myColumnGroup"].`[valueCol][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.valueCol]`<`[String][String]`>(0) }`
+     *
+     * To create a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for another kind of column, take a look at the functions
+     * [col][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.col],
+     * [colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup],
+     * and [frameCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.frameCol].
+     *
+     * @return A [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for the value column with the given argument if possible, else a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn].
+     * @throws [IllegalStateException] if the column with the given argument does not exist.
+     * @throws [IllegalArgumentException] if the column with the given argument is not a value column.
+     *
+     * @see [valueColumn]
+     * @see [ColumnsSelectionDsl.colGroup]
+     * @see [ColumnsSelectionDsl.frameCol]
+     * @see [ColumnsSelectionDsl.col]
+     *
+     *
+     *
+     * @param [index] The index of the value column.
+     * @throws [IndexOutOfBoundsException] if the index is out of bounds.
+     */
+    @Suppress("INAPPLICABLE_JVM_NAME")
+    @JvmName("valueColUnTyped")
+    public fun ColumnPath.valueCol(index: Int): SingleColumn<*> = valueCol<Any?>(index)
+
+    /**
+     * ## Value Col
+     *
+     * Creates a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] (or [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]) for a value column with the given argument which can be either
+     * an index ([Int]) or a reference to a column
+     * ([String], [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath], [KProperty], or [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor]; any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+     *
+     * This is a DSL-shorthand for [valueColumn][org.jetbrains.kotlinx.dataframe.api.valueColumn] and can be both typed and untyped (in case you're supplying
+     * a column name, -path, or index). In addition, extra runtime checks are in place to ensure that the column
+     * you specify is actually a value column.
+     * The function can also be called on [ColumnGroups][org.jetbrains.kotlinx.dataframe.ColumnGroupReference] to create
+     * an accessor for a value column inside a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[valueCol][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.valueCol]`<`[String][String]`>("valueColA") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[valueCol][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.valueCol]`(SomeType::valueColB) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[valueCol][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.valueCol]`(1) }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "pathTo"["myColumnGroup"].`[valueCol][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.valueCol]`(0) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "pathTo"["myColumnGroup"].`[valueCol][org.jetbrains.kotlinx.dataframe.api.ValueColColumnsSelectionDsl.valueCol]`<`[String][String]`>(0) }`
+     *
+     * To create a [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for another kind of column, take a look at the functions
+     * [col][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.col],
+     * [colGroup][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colGroup],
+     * and [frameCol][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.frameCol].
+     *
+     * @return A [ColumnAccessor][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor] for the value column with the given argument if possible, else a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn].
+     * @throws [IllegalStateException] if the column with the given argument does not exist.
+     * @throws [IllegalArgumentException] if the column with the given argument is not a value column.
+     *
+     * @see [valueColumn]
+     * @see [ColumnsSelectionDsl.colGroup]
+     * @see [ColumnsSelectionDsl.frameCol]
+     * @see [ColumnsSelectionDsl.col]
+     *
+     *
+     *
+     * @param [index] The index of the value column.
+     * @throws [IndexOutOfBoundsException] if the index is out of bounds.
+     * @param [C] The type of the value column.
+     */
+    public fun <C> ColumnPath.valueCol(index: Int): SingleColumn<C> = columnGroup(this).valueCol<C>(index)
+
+    // endregion
+}
+
+/**
+ * Checks the validity of this [SingleColumn],
+ * by adding a check to see it's a [ValueColumn] (so, a [SingleColumn]<*>)
+ * and throwing an [IllegalArgumentException] if it's not.
+ */
+internal fun <C> SingleColumn<C>.ensureIsValueColumn(): SingleColumn<C> =
+    onResolve { col: ColumnWithPath<*>? ->
+        require(col?.isValueColumn() != false) {
+            "Column at ${col?.path} is not a ValueColumn, but a ${col?.kind()}."
+        }
+    }
+
+/** Checks the validity of this [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn],
+ * by adding a check to see it's a [ValueColumn][org.jetbrains.kotlinx.dataframe.columns.ValueColumn] (so, a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]<*>)
+ * and throwing an [IllegalArgumentException] if it's not. */
+internal fun <C> ColumnAccessor<C>.ensureIsValueColumn(): ColumnAccessor<C> =
+    onResolve { col: ColumnWithPath<*>? ->
+        require(col?.isValueColumn() != false) {
+            "Column at ${col?.path} is not a ValueColumn, but a ${col?.kind()}."
+        }
+    }
+
+// endregion
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/valueCols.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/valueCols.kt
new file mode 100644
index 000000000..f1c04c02e
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/valueCols.kt
@@ -0,0 +1,362 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.DataRow
+import org.jetbrains.kotlinx.dataframe.Predicate
+import org.jetbrains.kotlinx.dataframe.columns.ColumnPath
+import org.jetbrains.kotlinx.dataframe.columns.ColumnReference
+import org.jetbrains.kotlinx.dataframe.columns.ColumnSet
+import org.jetbrains.kotlinx.dataframe.columns.ColumnWithPath
+import org.jetbrains.kotlinx.dataframe.columns.ColumnsResolver
+import org.jetbrains.kotlinx.dataframe.columns.SingleColumn
+import org.jetbrains.kotlinx.dataframe.columns.ValueColumn
+import org.jetbrains.kotlinx.dataframe.documentation.AccessApi
+import org.jetbrains.kotlinx.dataframe.impl.columns.TransformableColumnSet
+import kotlin.reflect.KProperty
+
+// region ColumnsSelectionDsl
+
+/**
+ * ## Value Columns [Columns Selection DSL][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl]
+ *
+ * See [Grammar] for all functions in this interface.
+ */
+public interface ValueColsColumnsSelectionDsl {
+
+    /**
+     * ## Value Columns Grammar
+     *
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * [(What is this notation?)][org.jetbrains.kotlinx.dataframe.documentation.DslGrammar]
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  ### Definitions:
+     *  `columnSet: `[`ColumnSet`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]`<*>`
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  `columnGroup: `[`SingleColumn`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]`<`[`DataRow`][org.jetbrains.kotlinx.dataframe.DataRow]`<*>> | `[`String`][String]`  |  `[`KProperty`][kotlin.reflect.KProperty]`<* | `[`DataRow`][org.jetbrains.kotlinx.dataframe.DataRow]`<*>> | `[`ColumnPath`][org.jetbrains.kotlinx.dataframe.columns.ColumnPath]
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  `condition: `[`ColumnFilter`][org.jetbrains.kotlinx.dataframe.ColumnFilter]
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  ### What can be called directly in the [Columns Selection DSL][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl]:
+     *
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  [**`valueCols`**][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.valueCols]`  [  `**`{ `**[`condition`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ConditionDef]**` }`**` ]`
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  ### What can be called on a [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]:
+     *
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  [`columnSet`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ColumnSetDef]
+     *
+     *  &nbsp;&nbsp;&nbsp;&nbsp;__`.`__[**`valueCols`**][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.valueCols]`  [  `**`{ `**[`condition`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ConditionDef]**` }`**` ]`
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  ### What can be called on a [Column Group (reference)][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ColumnGroupDef]:
+     *
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  [`columnGroup`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ColumnGroupDef]
+     *
+     *  &nbsp;&nbsp;&nbsp;&nbsp;__`.`__[**`valueCols`**][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.valueCols]`  [  `**`{ `**[`condition`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ConditionDef]**` }`**` ]`
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     */
+    public interface Grammar {
+
+        /** [**`valueCols`**][ColumnsSelectionDsl.valueCols] */
+        public interface PlainDslName
+
+        /** __`.`__[**`valueCols`**][ColumnsSelectionDsl.valueCols] */
+        public interface ColumnSetName
+
+        /** __`.`__[**`valueCols`**][ColumnsSelectionDsl.valueCols] */
+        public interface ColumnGroupName
+    }
+
+    /**
+     * ## Value Columns
+     * Creates a subset of columns from [this] that are [ValueColumns][ValueColumn].
+     *
+     * You can optionally use a [filter] to only include certain columns.
+     * [valueCols] can be called using any of the supported [APIs][AccessApi] (+ [ColumnPath]).
+     *
+     * This function operates solely on columns at the top-level.
+     *
+     * ### Check out: [Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][DataFrame.select]`  {  `[valueCols][ColumnsSelectionDsl.valueCols]` { it.`[name][ColumnReference.name]`.`[startsWith][String.startsWith]`("my") } }`
+     *
+     * `df.`[select][DataFrame.select]`  {  `[colsAtAnyDepth][ColumnsSelectionDsl.colsAtAnyDepth]`().`[valueCols][ColumnsSelectionDsl.valueCols]`() }`
+     *
+     * `df.`[select][DataFrame.select]` { "myColGroup".`[valueCols][String.valueCols]`() }`
+     *
+     * #### Examples for this overload:
+     *
+     *
+     *
+     * @param [filter] An optional [predicate][Predicate] to filter the value columns by.
+     * @return A [ColumnSet] of [ValueColumns][ValueColumn].
+     * @see [ColumnsSelectionDsl.colsOfKind]
+     * @see [ColumnsSelectionDsl.frameCols]
+     * @see [ColumnsSelectionDsl.colGroups]
+     * @see [ColumnsSelectionDsl.cols]
+     */
+    private interface CommonValueColsDocs {
+
+        /** Example argument */
+        interface ExampleArg
+    }
+
+    /**
+     * ## Value Columns
+     * Creates a subset of columns from [this] that are [ValueColumns][org.jetbrains.kotlinx.dataframe.columns.ValueColumn].
+     *
+     * You can optionally use a [filter] to only include certain columns.
+     * [valueCols][org.jetbrains.kotlinx.dataframe.api.ValueColsColumnsSelectionDsl.valueCols] can be called using any of the supported [APIs][org.jetbrains.kotlinx.dataframe.documentation.AccessApi] (+ [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath]).
+     *
+     * This function operates solely on columns at the top-level.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ValueColsColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[valueCols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.valueCols]` { it.`[name][org.jetbrains.kotlinx.dataframe.columns.ColumnReference.name]`.`[startsWith][String.startsWith]`("my") } }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsAtAnyDepth][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsAtAnyDepth]`().`[valueCols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.valueCols]`() }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "myColGroup".`[valueCols][kotlin.String.valueCols]`() }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][DataFrame.select]`  {  `[cols][ColumnsSelectionDsl.cols]` { it.`[name][ColumnReference.name]`.`[startsWith][String.startsWith]`("my") }.`[valueCols][ColumnSet.valueCols]`() }`
+     *
+     * `// NOTE: This can be shortened to just:`
+     *
+     * `df.`[select][DataFrame.select]`  {  `[valueCols][ColumnsSelectionDsl.valueCols]` { it.`[name][ColumnReference.name]`.`[startsWith][String.startsWith]`("my") } }`
+     *
+     * @param [filter] An optional [predicate][org.jetbrains.kotlinx.dataframe.Predicate] to filter the value columns by.
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] of [ValueColumns][org.jetbrains.kotlinx.dataframe.columns.ValueColumn].
+     * @see [ColumnsSelectionDsl.colsOfKind]
+     * @see [ColumnsSelectionDsl.frameCols]
+     * @see [ColumnsSelectionDsl.colGroups]
+     * @see [ColumnsSelectionDsl.cols]
+     */
+    public fun ColumnSet<*>.valueCols(filter: Predicate<ValueColumn<*>> = { true }): TransformableColumnSet<*> =
+        valueColumnsInternal(filter)
+
+    /**
+     * ## Value Columns
+     * Creates a subset of columns from [this] that are [ValueColumns][org.jetbrains.kotlinx.dataframe.columns.ValueColumn].
+     *
+     * You can optionally use a [filter] to only include certain columns.
+     * [valueCols][org.jetbrains.kotlinx.dataframe.api.ValueColsColumnsSelectionDsl.valueCols] can be called using any of the supported [APIs][org.jetbrains.kotlinx.dataframe.documentation.AccessApi] (+ [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath]).
+     *
+     * This function operates solely on columns at the top-level.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ValueColsColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[valueCols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.valueCols]` { it.`[name][org.jetbrains.kotlinx.dataframe.columns.ColumnReference.name]`.`[startsWith][String.startsWith]`("my") } }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsAtAnyDepth][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsAtAnyDepth]`().`[valueCols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.valueCols]`() }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "myColGroup".`[valueCols][kotlin.String.valueCols]`() }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][DataFrame.select]`  {  `[valueCols][ColumnsSelectionDsl.valueCols]`() }`
+     *
+     * `df.`[select][DataFrame.select]`  {  `[valueCols][ColumnsSelectionDsl.valueCols]` { it.`[any][ColumnWithPath.any]` { it == "Alice" } } }`
+     *
+     * @param [filter] An optional [predicate][org.jetbrains.kotlinx.dataframe.Predicate] to filter the value columns by.
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] of [ValueColumns][org.jetbrains.kotlinx.dataframe.columns.ValueColumn].
+     * @see [ColumnsSelectionDsl.colsOfKind]
+     * @see [ColumnsSelectionDsl.frameCols]
+     * @see [ColumnsSelectionDsl.colGroups]
+     * @see [ColumnsSelectionDsl.cols]
+     */
+    public fun ColumnsSelectionDsl<*>.valueCols(
+        filter: Predicate<ValueColumn<*>> = { true },
+    ): TransformableColumnSet<*> = asSingleColumn().valueColumnsInternal(filter)
+
+    /**
+     * ## Value Columns
+     * Creates a subset of columns from [this] that are [ValueColumns][org.jetbrains.kotlinx.dataframe.columns.ValueColumn].
+     *
+     * You can optionally use a [filter] to only include certain columns.
+     * [valueCols][org.jetbrains.kotlinx.dataframe.api.ValueColsColumnsSelectionDsl.valueCols] can be called using any of the supported [APIs][org.jetbrains.kotlinx.dataframe.documentation.AccessApi] (+ [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath]).
+     *
+     * This function operates solely on columns at the top-level.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ValueColsColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[valueCols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.valueCols]` { it.`[name][org.jetbrains.kotlinx.dataframe.columns.ColumnReference.name]`.`[startsWith][String.startsWith]`("my") } }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsAtAnyDepth][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsAtAnyDepth]`().`[valueCols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.valueCols]`() }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "myColGroup".`[valueCols][kotlin.String.valueCols]`() }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][DataFrame.select]` { myColGroup.`[valueCols][SingleColumn.valueCols]`() }`
+     *
+     * `df.`[select][DataFrame.select]` { myColGroup.`[valueCols][SingleColumn.valueCols]` { it.`[any][ColumnWithPath.any]` { it == "Alice" } } }`
+     *
+     * @param [filter] An optional [predicate][org.jetbrains.kotlinx.dataframe.Predicate] to filter the value columns by.
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] of [ValueColumns][org.jetbrains.kotlinx.dataframe.columns.ValueColumn].
+     * @see [ColumnsSelectionDsl.colsOfKind]
+     * @see [ColumnsSelectionDsl.frameCols]
+     * @see [ColumnsSelectionDsl.colGroups]
+     * @see [ColumnsSelectionDsl.cols]
+     */
+    public fun SingleColumn<DataRow<*>>.valueCols(
+        filter: Predicate<ValueColumn<*>> = { true },
+    ): TransformableColumnSet<*> = this.ensureIsColumnGroup().valueColumnsInternal(filter)
+
+    /**
+     * ## Value Columns
+     * Creates a subset of columns from [this] that are [ValueColumns][org.jetbrains.kotlinx.dataframe.columns.ValueColumn].
+     *
+     * You can optionally use a [filter] to only include certain columns.
+     * [valueCols][org.jetbrains.kotlinx.dataframe.api.ValueColsColumnsSelectionDsl.valueCols] can be called using any of the supported [APIs][org.jetbrains.kotlinx.dataframe.documentation.AccessApi] (+ [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath]).
+     *
+     * This function operates solely on columns at the top-level.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ValueColsColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[valueCols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.valueCols]` { it.`[name][org.jetbrains.kotlinx.dataframe.columns.ColumnReference.name]`.`[startsWith][String.startsWith]`("my") } }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsAtAnyDepth][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsAtAnyDepth]`().`[valueCols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.valueCols]`() }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "myColGroup".`[valueCols][kotlin.String.valueCols]`() }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][DataFrame.select]` { "myColGroup".`[valueCols][String.valueCols]` { it.`[any][ColumnWithPath.any]` { it == "Alice" } } }`
+     *
+     * `df.`[select][DataFrame.select]` { "myColGroup".`[valueCols][String.valueCols]`() }`
+     *
+     * @param [filter] An optional [predicate][org.jetbrains.kotlinx.dataframe.Predicate] to filter the value columns by.
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] of [ValueColumns][org.jetbrains.kotlinx.dataframe.columns.ValueColumn].
+     * @see [ColumnsSelectionDsl.colsOfKind]
+     * @see [ColumnsSelectionDsl.frameCols]
+     * @see [ColumnsSelectionDsl.colGroups]
+     * @see [ColumnsSelectionDsl.cols]
+     */
+    public fun String.valueCols(filter: Predicate<ValueColumn<*>> = { true }): TransformableColumnSet<*> =
+        columnGroup(this).valueCols(filter)
+
+    /**
+     * ## Value Columns
+     * Creates a subset of columns from [this] that are [ValueColumns][org.jetbrains.kotlinx.dataframe.columns.ValueColumn].
+     *
+     * You can optionally use a [filter] to only include certain columns.
+     * [valueCols][org.jetbrains.kotlinx.dataframe.api.ValueColsColumnsSelectionDsl.valueCols] can be called using any of the supported [APIs][org.jetbrains.kotlinx.dataframe.documentation.AccessApi] (+ [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath]).
+     *
+     * This function operates solely on columns at the top-level.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ValueColsColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[valueCols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.valueCols]` { it.`[name][org.jetbrains.kotlinx.dataframe.columns.ColumnReference.name]`.`[startsWith][String.startsWith]`("my") } }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsAtAnyDepth][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsAtAnyDepth]`().`[valueCols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.valueCols]`() }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "myColGroup".`[valueCols][kotlin.String.valueCols]`() }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][DataFrame.select]` { Type::myColumnGroup.`[valueCols][KProperty.valueCols]` { it.`[any][ColumnWithPath.any]` { it == "Alice" } } }`
+     *
+     * `df.`[select][DataFrame.select]` { Type::myColumnGroup.`[valueCols][KProperty.valueCols]`() }`
+     *
+     * `df.`[select][DataFrame.select]` { DataSchemaType::myColumnGroup.`[valueCols][KProperty.valueCols]`() }`
+     *
+     * @param [filter] An optional [predicate][org.jetbrains.kotlinx.dataframe.Predicate] to filter the value columns by.
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] of [ValueColumns][org.jetbrains.kotlinx.dataframe.columns.ValueColumn].
+     * @see [ColumnsSelectionDsl.colsOfKind]
+     * @see [ColumnsSelectionDsl.frameCols]
+     * @see [ColumnsSelectionDsl.colGroups]
+     * @see [ColumnsSelectionDsl.cols]
+     */
+    public fun KProperty<*>.valueCols(filter: Predicate<ValueColumn<*>> = { true }): TransformableColumnSet<*> =
+        columnGroup(this).valueCols(filter)
+
+    /**
+     * ## Value Columns
+     * Creates a subset of columns from [this] that are [ValueColumns][org.jetbrains.kotlinx.dataframe.columns.ValueColumn].
+     *
+     * You can optionally use a [filter] to only include certain columns.
+     * [valueCols][org.jetbrains.kotlinx.dataframe.api.ValueColsColumnsSelectionDsl.valueCols] can be called using any of the supported [APIs][org.jetbrains.kotlinx.dataframe.documentation.AccessApi] (+ [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath]).
+     *
+     * This function operates solely on columns at the top-level.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.ValueColsColumnsSelectionDsl.Grammar]
+     *
+     * #### For example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[valueCols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.valueCols]` { it.`[name][org.jetbrains.kotlinx.dataframe.columns.ColumnReference.name]`.`[startsWith][String.startsWith]`("my") } }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[colsAtAnyDepth][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsAtAnyDepth]`().`[valueCols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.valueCols]`() }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "myColGroup".`[valueCols][kotlin.String.valueCols]`() }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][DataFrame.select]` { "pathTo"["myGroupCol"].`[valueCols][ColumnPath.valueCols]`() }`
+     *
+     * @param [filter] An optional [predicate][org.jetbrains.kotlinx.dataframe.Predicate] to filter the value columns by.
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] of [ValueColumns][org.jetbrains.kotlinx.dataframe.columns.ValueColumn].
+     * @see [ColumnsSelectionDsl.colsOfKind]
+     * @see [ColumnsSelectionDsl.frameCols]
+     * @see [ColumnsSelectionDsl.colGroups]
+     * @see [ColumnsSelectionDsl.cols]
+     */
+    public fun ColumnPath.valueCols(filter: Predicate<ValueColumn<*>> = { true }): TransformableColumnSet<*> =
+        columnGroup(this).valueCols(filter)
+}
+
+/**
+ * Returns a TransformableColumnSet containing the value columns that satisfy the given filter.
+ *
+ * @param filter The filter function to apply on each value column. Must accept a ValueColumn object and return a Boolean.
+ * @return A [TransformableColumnSet] containing the value columns that satisfy the filter.
+ */
+internal fun ColumnsResolver<*>.valueColumnsInternal(filter: (ValueColumn<*>) -> Boolean): TransformableColumnSet<*> =
+    colsInternal { it.isValueColumn() && filter(it) }
+
+// endregion
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/valueCounts.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/valueCounts.kt
new file mode 100644
index 000000000..1c96776b4
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/valueCounts.kt
@@ -0,0 +1,97 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import org.jetbrains.kotlinx.dataframe.AnyColumnReference
+import org.jetbrains.kotlinx.dataframe.ColumnsSelector
+import org.jetbrains.kotlinx.dataframe.DataColumn
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.annotations.DataSchema
+import org.jetbrains.kotlinx.dataframe.columns.toColumnSet
+import org.jetbrains.kotlinx.dataframe.impl.nameGenerator
+import kotlin.reflect.KProperty
+import kotlin.reflect.full.withNullability
+import kotlin.reflect.typeOf
+
+// region DataSchema
+
+@DataSchema
+public interface ValueCount {
+    public val count: Int
+}
+
+// endregion
+
+// region DataColumn
+
+internal val defaultCountColumnName: String = ValueCount::count.name
+
+public fun <T> DataColumn<T>.valueCounts(
+    sort: Boolean = true,
+    ascending: Boolean = false,
+    dropNA: Boolean = true,
+    resultColumn: String = defaultCountColumnName,
+): DataFrame<ValueCount> {
+    var grouped = toList().groupBy { it }.map { it.key to it.value.size }
+    if (sort) {
+        grouped = if (ascending) {
+            grouped.sortedBy { it.second }
+        } else {
+            grouped.sortedByDescending { it.second }
+        }
+    }
+    if (dropNA) grouped = grouped.filter { !it.first.isNA }
+    val nulls = if (dropNA) false else hasNulls()
+    val values = DataColumn.create(name(), grouped.map { it.first }, type().withNullability(nulls))
+    val countName = if (resultColumn == name()) resultColumn + "1" else resultColumn
+    val counts = DataColumn.create(countName, grouped.map { it.second }, typeOf<Int>())
+    return dataFrameOf(values, counts).cast()
+}
+
+// endregion
+
+// region DataFrame
+
+public fun <T> DataFrame<T>.valueCounts(
+    sort: Boolean = true,
+    ascending: Boolean = false,
+    dropNA: Boolean = true,
+    resultColumn: String = defaultCountColumnName,
+    columns: ColumnsSelector<T, *>? = null,
+): DataFrame<T> {
+    var df = if (columns != null) select(columns) else this
+    if (dropNA) df = df.dropNA()
+
+    val rows by columnGroup()
+    val countName = nameGenerator().addUnique(resultColumn)
+    return df
+        .asColumnGroup(rows)
+        .asDataColumn()
+        .valueCounts(sort, ascending, dropNA, countName)
+        .ungroup(rows)
+        .cast()
+}
+
+public fun <T> DataFrame<T>.valueCounts(
+    vararg columns: String,
+    sort: Boolean = true,
+    ascending: Boolean = false,
+    dropNA: Boolean = true,
+    resultColumn: String = defaultCountColumnName,
+): DataFrame<T> = valueCounts(sort, ascending, dropNA, resultColumn) { columns.toColumnSet() }
+
+public fun <T> DataFrame<T>.valueCounts(
+    vararg columns: AnyColumnReference,
+    sort: Boolean = true,
+    ascending: Boolean = false,
+    dropNA: Boolean = true,
+    resultColumn: String = defaultCountColumnName,
+): DataFrame<T> = valueCounts(sort, ascending, dropNA, resultColumn) { columns.toColumnSet() }
+
+public fun <T> DataFrame<T>.valueCounts(
+    vararg columns: KProperty<*>,
+    sort: Boolean = true,
+    ascending: Boolean = false,
+    dropNA: Boolean = true,
+    resultColumn: String = defaultCountColumnName,
+): DataFrame<T> = valueCounts(sort, ascending, dropNA, resultColumn) { columns.toColumnSet() }
+
+// endregion
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/values.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/values.kt
new file mode 100644
index 000000000..e63509f61
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/values.kt
@@ -0,0 +1,192 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import org.jetbrains.kotlinx.dataframe.AnyColumnReference
+import org.jetbrains.kotlinx.dataframe.ColumnsSelector
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.DataRow
+import org.jetbrains.kotlinx.dataframe.aggregation.ColumnsForAggregateSelector
+import org.jetbrains.kotlinx.dataframe.columns.toColumnSet
+import org.jetbrains.kotlinx.dataframe.impl.aggregation.columnValues
+import org.jetbrains.kotlinx.dataframe.impl.aggregation.internal
+import org.jetbrains.kotlinx.dataframe.impl.aggregation.remainingColumnsSelector
+import org.jetbrains.kotlinx.dataframe.impl.valuesImpl
+import kotlin.reflect.KProperty
+
+// region DataFrame
+
+public fun <T, C> DataFrame<T>.values(byRow: Boolean = false, columns: ColumnsSelector<T, C>): Sequence<C> =
+    valuesImpl(byRow, columns)
+
+public fun <T> DataFrame<T>.values(byRows: Boolean = false): Sequence<Any?> = values(byRows) { all() }
+
+public fun <T, C> DataFrame<T>.valuesNotNull(byRow: Boolean = false, columns: ColumnsSelector<T, C?>): Sequence<C> =
+    values(byRow, columns).filterNotNull()
+
+public fun <T> DataFrame<T>.valuesNotNull(byRow: Boolean = false): Sequence<Any> = valuesNotNull(byRow) { all() }
+
+// endregion
+
+// region GroupBy
+
+public fun <T> Grouped<T>.values(
+    vararg columns: AnyColumnReference,
+    dropNA: Boolean = false,
+    distinct: Boolean = false,
+): DataFrame<T> = values(dropNA, distinct) { columns.toColumnSet() }
+
+public fun <T> Grouped<T>.values(
+    vararg columns: String,
+    dropNA: Boolean = false,
+    distinct: Boolean = false,
+): DataFrame<T> = values(dropNA, distinct) { columns.toColumnSet() }
+
+public fun <T> Grouped<T>.values(
+    dropNA: Boolean = false,
+    distinct: Boolean = false,
+    columns: ColumnsForAggregateSelector<T, *>,
+): DataFrame<T> = aggregate { internal().columnValues(columns, true, dropNA, distinct) }
+
+public fun <T> Grouped<T>.values(dropNA: Boolean = false, distinct: Boolean = false): DataFrame<T> =
+    values(dropNA, distinct, remainingColumnsSelector())
+
+// endregion
+
+// region ReducedGroupBy
+
+public fun <T, G> ReducedGroupBy<T, G>.values(): DataFrame<G> = values(groupBy.remainingColumnsSelector())
+
+public fun <T, G> ReducedGroupBy<T, G>.values(vararg columns: AnyColumnReference): DataFrame<G> =
+    values { columns.toColumnSet() }
+
+public fun <T, G> ReducedGroupBy<T, G>.values(vararg columns: String): DataFrame<G> = values { columns.toColumnSet() }
+
+public fun <T, G> ReducedGroupBy<T, G>.values(vararg columns: KProperty<*>): DataFrame<G> =
+    values { columns.toColumnSet() }
+
+public fun <T, G> ReducedGroupBy<T, G>.values(columns: ColumnsForAggregateSelector<G, *>): DataFrame<G> =
+    groupBy.aggregate { internal().columnValues(columns, reducer) }
+
+// endregion
+
+// region Pivot
+
+public fun <T> Pivot<T>.values(
+    dropNA: Boolean = false,
+    distinct: Boolean = false,
+    separate: Boolean = false,
+    columns: ColumnsForAggregateSelector<T, *>,
+): DataRow<T> = delegate { values(dropNA, distinct, separate, columns) }
+
+public fun <T> Pivot<T>.values(
+    vararg columns: AnyColumnReference,
+    dropNA: Boolean = false,
+    distinct: Boolean = false,
+    separate: Boolean = false,
+): DataRow<T> = values(dropNA, distinct, separate) { columns.toColumnSet() }
+
+public fun <T> Pivot<T>.values(
+    vararg columns: String,
+    dropNA: Boolean = false,
+    distinct: Boolean = false,
+    separate: Boolean = false,
+): DataRow<T> = values(dropNA, distinct, separate) { columns.toColumnSet() }
+
+public fun <T> Pivot<T>.values(
+    vararg columns: KProperty<*>,
+    dropNA: Boolean = false,
+    distinct: Boolean = false,
+    separate: Boolean = false,
+): DataRow<T> = values(dropNA, distinct, separate) { columns.toColumnSet() }
+
+public fun <T> Pivot<T>.values(
+    dropNA: Boolean = false,
+    distinct: Boolean = false,
+    separate: Boolean = false,
+): DataRow<T> =
+    delegate {
+        values(dropNA, distinct, separate)
+    }
+
+// endregion
+
+// region ReducedPivot
+
+public fun <T> ReducedPivot<T>.values(separate: Boolean = false): DataRow<T> =
+    pivot.delegate { reduce(reducer).values(separate = separate) }
+
+public fun <T> ReducedPivot<T>.values(vararg columns: AnyColumnReference, separate: Boolean = false): DataRow<T> =
+    values(separate) { columns.toColumnSet() }
+
+public fun <T> ReducedPivot<T>.values(vararg columns: String, separate: Boolean = false): DataRow<T> =
+    values(separate) { columns.toColumnSet() }
+
+public fun <T> ReducedPivot<T>.values(vararg columns: KProperty<*>, separate: Boolean = false): DataRow<T> =
+    values(separate) { columns.toColumnSet() }
+
+public fun <T> ReducedPivot<T>.values(
+    separate: Boolean = false,
+    columns: ColumnsForAggregateSelector<T, *>,
+): DataRow<T> = pivot.delegate { reduce(reducer).values(separate = separate, columns = columns) }
+
+// endregion
+
+// region PivotGroupBy
+
+public fun <T> PivotGroupBy<T>.values(
+    dropNA: Boolean = false,
+    distinct: Boolean = false,
+    separate: Boolean = false,
+): DataFrame<T> = values(dropNA, distinct, separate, remainingColumnsSelector())
+
+public fun <T> PivotGroupBy<T>.values(
+    vararg columns: AnyColumnReference,
+    dropNA: Boolean = false,
+    distinct: Boolean = false,
+    separate: Boolean = false,
+): DataFrame<T> = values(dropNA, distinct, separate) { columns.toColumnSet() }
+
+public fun <T> PivotGroupBy<T>.values(
+    vararg columns: String,
+    dropNA: Boolean = false,
+    distinct: Boolean = false,
+    separate: Boolean = false,
+): DataFrame<T> = values(dropNA, distinct, separate) { columns.toColumnSet() }
+
+public fun <T> PivotGroupBy<T>.values(
+    vararg columns: KProperty<*>,
+    dropNA: Boolean = false,
+    distinct: Boolean = false,
+    separate: Boolean = false,
+): DataFrame<T> = values(dropNA, distinct, separate) { columns.toColumnSet() }
+
+public fun <T> PivotGroupBy<T>.values(
+    dropNA: Boolean = false,
+    distinct: Boolean = false,
+    separate: Boolean = false,
+    columns: ColumnsForAggregateSelector<T, *>,
+): DataFrame<T> = aggregate(separate = separate) { internal().columnValues(columns, false, dropNA, distinct) }
+
+// endregion
+
+// region ReducedPivotGroupBy
+
+public fun <T> ReducedPivotGroupBy<T>.values(separate: Boolean = false): DataFrame<T> =
+    values(separate, pivot.remainingColumnsSelector())
+
+public fun <T> ReducedPivotGroupBy<T>.values(
+    vararg columns: AnyColumnReference,
+    separate: Boolean = false,
+): DataFrame<T> = values(separate) { columns.toColumnSet() }
+
+public fun <T> ReducedPivotGroupBy<T>.values(vararg columns: String, separate: Boolean = false): DataFrame<T> =
+    values(separate) { columns.toColumnSet() }
+
+public fun <T> ReducedPivotGroupBy<T>.values(vararg columns: KProperty<*>, separate: Boolean = false): DataFrame<T> =
+    values(separate) { columns.toColumnSet() }
+
+public fun <T> ReducedPivotGroupBy<T>.values(
+    separate: Boolean = false,
+    columns: ColumnsForAggregateSelector<T, *>,
+): DataFrame<T> = pivot.aggregate(separate = separate) { internal().columnValues(columns, reducer) }
+
+// endregion
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/with.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/with.kt
new file mode 100644
index 000000000..bb039e2b9
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/with.kt
@@ -0,0 +1,56 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import org.jetbrains.kotlinx.dataframe.AnyColumnReference
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.DataRow
+import org.jetbrains.kotlinx.dataframe.RowExpression
+import org.jetbrains.kotlinx.dataframe.impl.aggregation.internal
+import org.jetbrains.kotlinx.dataframe.impl.aggregation.withExpr
+import org.jetbrains.kotlinx.dataframe.impl.emptyPath
+import kotlin.reflect.typeOf
+
+// region Pivot
+
+public inline fun <T, reified V> Pivot<T>.with(noinline expression: RowExpression<T, V>): DataRow<T> =
+    delegate {
+        with(expression)
+    }
+
+// endregion
+
+// region ReducedPivot
+
+public inline fun <T, reified V> ReducedPivot<T>.with(noinline expression: RowExpression<T, V>): DataRow<T> =
+    pivot.delegate {
+        reduce(reducer).with(expression)
+    }
+
+// endregion
+
+// region PivotGroupBy
+
+public inline fun <T, reified V> PivotGroupBy<T>.with(noinline expression: RowExpression<T, V>): DataFrame<T> {
+    val type = typeOf<V>()
+    return aggregate { internal().withExpr(type, emptyPath(), expression) }
+}
+
+// endregion
+
+// region ReducedPivotGroupBy
+
+public inline fun <T, reified V> ReducedPivotGroupBy<T>.with(noinline expression: RowExpression<T, V>): DataFrame<T> {
+    val type = typeOf<V>()
+    return pivot.aggregate {
+        val value = reducer(this)?.let {
+            val value = expression(it, it)
+            if (value is AnyColumnReference) {
+                it[value]
+            } else {
+                value
+            }
+        }
+        internal().yield(emptyPath(), value, type)
+    }
+}
+
+// endregion
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/withoutNulls.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/withoutNulls.kt
new file mode 100644
index 000000000..ed6f5ccb0
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/withoutNulls.kt
@@ -0,0 +1,283 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.DataRow
+import org.jetbrains.kotlinx.dataframe.api.WithoutNullsColumnsSelectionDsl.Grammar
+import org.jetbrains.kotlinx.dataframe.columns.ColumnGroup
+import org.jetbrains.kotlinx.dataframe.columns.ColumnPath
+import org.jetbrains.kotlinx.dataframe.columns.ColumnSet
+import org.jetbrains.kotlinx.dataframe.columns.SingleColumn
+import org.jetbrains.kotlinx.dataframe.impl.columns.transform
+import kotlin.reflect.KProperty
+
+// region ColumnsSelectionDsl
+
+/**
+ * ## Without Nulls [Columns Selection DSL][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl]
+ *
+ * See [Grammar] for all functions in this interface.
+ */
+public interface WithoutNullsColumnsSelectionDsl {
+
+    /**
+     * ## (Cols) Without Nulls Grammar
+     *
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * [(What is this notation?)][org.jetbrains.kotlinx.dataframe.documentation.DslGrammar]
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  ### Definitions:
+     *  `columnSet: `[`ColumnSet`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]`<*>`
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  `columnGroup: `[`SingleColumn`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]`<`[`DataRow`][org.jetbrains.kotlinx.dataframe.DataRow]`<*>> | `[`String`][String]`  |  `[`KProperty`][kotlin.reflect.KProperty]`<* | `[`DataRow`][org.jetbrains.kotlinx.dataframe.DataRow]`<*>> | `[`ColumnPath`][org.jetbrains.kotlinx.dataframe.columns.ColumnPath]
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  ### What can be called directly in the [Columns Selection DSL][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl]:
+     *
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  [**`withoutNulls`**][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.withoutNulls]**`()`**
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  ### What can be called on a [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]:
+     *
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  [`columnSet`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ColumnSetDef]
+     *
+     *  &nbsp;&nbsp;&nbsp;&nbsp;__`.`__[**`withoutNulls`**][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.withoutNulls]**`()`**
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  ### What can be called on a [Column Group (reference)][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ColumnGroupDef]:
+     *
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  [`columnGroup`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ColumnGroupDef]
+     *
+     *  &nbsp;&nbsp;&nbsp;&nbsp;__`.`__[**`colsWithoutNulls`**][org.jetbrains.kotlinx.dataframe.api.WithoutNullsColumnsSelectionDsl.colsWithoutNulls]**`()`**
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     */
+    public interface Grammar {
+
+        /** [**`withoutNulls`**][ColumnsSelectionDsl.withoutNulls] */
+        public interface PlainDslName
+
+        /** __`.`__[**`withoutNulls`**][ColumnsSelectionDsl.withoutNulls] */
+        public interface ColumnSetName
+
+        /** __`.`__[**`colsWithoutNulls`**][ColumnsSelectionDsl.colsWithoutNulls] */
+        public interface ColumnGroupName
+    }
+
+    /**
+     * ## (Cols) Without Nulls
+     * Returns a new [ColumnSet] that contains only columns in [this] that do not have `null` values.
+     *
+     * This function operates solely on columns at the top-level.
+     *
+     * NOTE: For [column groups][ColumnGroup], `withoutNulls` is named `colsWithoutNulls` to avoid confusion.
+     *
+     * ### Check out: [Grammar]
+     *
+     * #### For Example:
+     *
+     * `df.`[select][DataFrame.select]`  {  `[all][ColumnsSelectionDsl.all]`().`[nameContains][ColumnsSelectionDsl.colsNameContains]`("middleName").`[withoutNulls][ColumnSet.withoutNulls]`() }`
+     *
+     * `df.`[select][DataFrame.select]`  {  `[withoutNulls][ColumnsSelectionDsl.withoutNulls]`() }`
+     *
+     * `df.`[select][DataFrame.select]` { Type::userData.`[colsWithoutNulls][SingleColumn.colsWithoutNulls]`() }`
+     *
+     * #### Examples for this overload:
+     *
+     *
+     *
+     * @return A [ColumnSet] containing only columns that do not contain `null`s and are thus non-nullable.
+     */
+    private interface CommonWithoutNullsDocs {
+
+        interface ExampleArg
+    }
+
+    /**
+     * ## (Cols) Without Nulls
+     * Returns a new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] that contains only columns in [this] that do not have `null` values.
+     *
+     * This function operates solely on columns at the top-level.
+     *
+     * NOTE: For [column groups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup], `withoutNulls` is named `colsWithoutNulls` to avoid confusion.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.WithoutNullsColumnsSelectionDsl.Grammar]
+     *
+     * #### For Example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[all][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.all]`().`[nameContains][org.jetbrains.kotlinx.dataframe.api.ColumnNameFiltersColumnsSelectionDsl.colsNameContains]`("middleName").`[withoutNulls][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.withoutNulls]`() }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[withoutNulls][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.withoutNulls]`() }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { Type::userData.`[colsWithoutNulls][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.colsWithoutNulls]`() }`
+     *
+     * #### Examples for this overload:
+     *
+     *
+     *
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing only columns that do not contain `null`s and are thus non-nullable.
+     */
+    @Suppress("UNCHECKED_CAST")
+    public fun <C> ColumnSet<C?>.withoutNulls(): ColumnSet<C & Any> =
+        transform { cols -> cols.filter { !it.hasNulls() } } as ColumnSet<C & Any>
+
+    /**
+     * ## (Cols) Without Nulls
+     * Returns a new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] that contains only columns in [this] that do not have `null` values.
+     *
+     * This function operates solely on columns at the top-level.
+     *
+     * NOTE: For [column groups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup], `withoutNulls` is named `colsWithoutNulls` to avoid confusion.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.WithoutNullsColumnsSelectionDsl.Grammar]
+     *
+     * #### For Example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[all][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.all]`().`[nameContains][org.jetbrains.kotlinx.dataframe.api.ColumnNameFiltersColumnsSelectionDsl.colsNameContains]`("middleName").`[withoutNulls][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.withoutNulls]`() }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[withoutNulls][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.withoutNulls]`() }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { Type::userData.`[colsWithoutNulls][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.colsWithoutNulls]`() }`
+     *
+     * #### Examples for this overload:
+     *
+     *
+     *
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing only columns that do not contain `null`s and are thus non-nullable.
+     */
+    public fun ColumnsSelectionDsl<*>.withoutNulls(): ColumnSet<Any> = asSingleColumn().colsWithoutNulls()
+
+    /**
+     * ## (Cols) Without Nulls
+     * Returns a new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] that contains only columns in [this] that do not have `null` values.
+     *
+     * This function operates solely on columns at the top-level.
+     *
+     * NOTE: For [column groups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup], `withoutNulls` is named `colsWithoutNulls` to avoid confusion.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.WithoutNullsColumnsSelectionDsl.Grammar]
+     *
+     * #### For Example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[all][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.all]`().`[nameContains][org.jetbrains.kotlinx.dataframe.api.ColumnNameFiltersColumnsSelectionDsl.colsNameContains]`("middleName").`[withoutNulls][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.withoutNulls]`() }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[withoutNulls][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.withoutNulls]`() }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { Type::userData.`[colsWithoutNulls][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.colsWithoutNulls]`() }`
+     *
+     * #### Examples for this overload:
+     *
+     *
+     *
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing only columns that do not contain `null`s and are thus non-nullable.
+     */
+    public fun SingleColumn<DataRow<*>>.colsWithoutNulls(): ColumnSet<Any> =
+        ensureIsColumnGroup().allColumnsInternal().withoutNulls()
+
+    /**
+     * ## (Cols) Without Nulls
+     * Returns a new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] that contains only columns in [this] that do not have `null` values.
+     *
+     * This function operates solely on columns at the top-level.
+     *
+     * NOTE: For [column groups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup], `withoutNulls` is named `colsWithoutNulls` to avoid confusion.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.WithoutNullsColumnsSelectionDsl.Grammar]
+     *
+     * #### For Example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[all][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.all]`().`[nameContains][org.jetbrains.kotlinx.dataframe.api.ColumnNameFiltersColumnsSelectionDsl.colsNameContains]`("middleName").`[withoutNulls][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.withoutNulls]`() }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[withoutNulls][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.withoutNulls]`() }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { Type::userData.`[colsWithoutNulls][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.colsWithoutNulls]`() }`
+     *
+     * #### Examples for this overload:
+     *
+     *
+     *
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing only columns that do not contain `null`s and are thus non-nullable.
+     */
+    public fun String.colsWithoutNulls(): ColumnSet<Any> = columnGroup(this).colsWithoutNulls()
+
+    /**
+     * ## (Cols) Without Nulls
+     * Returns a new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] that contains only columns in [this] that do not have `null` values.
+     *
+     * This function operates solely on columns at the top-level.
+     *
+     * NOTE: For [column groups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup], `withoutNulls` is named `colsWithoutNulls` to avoid confusion.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.WithoutNullsColumnsSelectionDsl.Grammar]
+     *
+     * #### For Example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[all][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.all]`().`[nameContains][org.jetbrains.kotlinx.dataframe.api.ColumnNameFiltersColumnsSelectionDsl.colsNameContains]`("middleName").`[withoutNulls][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.withoutNulls]`() }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[withoutNulls][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.withoutNulls]`() }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { Type::userData.`[colsWithoutNulls][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.colsWithoutNulls]`() }`
+     *
+     * #### Examples for this overload:
+     *
+     *
+     *
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing only columns that do not contain `null`s and are thus non-nullable.
+     */
+    public fun KProperty<*>.colsWithoutNulls(): ColumnSet<Any> = columnGroup(this).colsWithoutNulls()
+
+    /**
+     * ## (Cols) Without Nulls
+     * Returns a new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] that contains only columns in [this] that do not have `null` values.
+     *
+     * This function operates solely on columns at the top-level.
+     *
+     * NOTE: For [column groups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup], `withoutNulls` is named `colsWithoutNulls` to avoid confusion.
+     *
+     * ### Check out: [Grammar][org.jetbrains.kotlinx.dataframe.api.WithoutNullsColumnsSelectionDsl.Grammar]
+     *
+     * #### For Example:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[all][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.all]`().`[nameContains][org.jetbrains.kotlinx.dataframe.api.ColumnNameFiltersColumnsSelectionDsl.colsNameContains]`("middleName").`[withoutNulls][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.withoutNulls]`() }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]`  {  `[withoutNulls][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.withoutNulls]`() }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { Type::userData.`[colsWithoutNulls][org.jetbrains.kotlinx.dataframe.columns.SingleColumn.colsWithoutNulls]`() }`
+     *
+     * #### Examples for this overload:
+     *
+     *
+     *
+     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing only columns that do not contain `null`s and are thus non-nullable.
+     */
+    public fun ColumnPath.colsWithoutNulls(): ColumnSet<Any> = columnGroup(this).colsWithoutNulls()
+}
+
+// endregion
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/xs.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/xs.kt
new file mode 100644
index 000000000..af6efa877
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/xs.kt
@@ -0,0 +1,29 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import org.jetbrains.kotlinx.dataframe.ColumnsSelector
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.impl.api.xsImpl
+
+// region DataFrame
+
+public fun <T> DataFrame<T>.xs(vararg keyValues: Any?): DataFrame<T> =
+    xs(*keyValues) {
+        colsAtAnyDepth { !it.isColumnGroup() }.take(keyValues.size)
+    }
+
+public fun <T, C> DataFrame<T>.xs(vararg keyValues: C, keyColumns: ColumnsSelector<T, C>): DataFrame<T> =
+    xsImpl(keyColumns, false, *keyValues)
+
+// endregion
+
+// region GroupBy
+
+public fun <T, G> GroupBy<T, G>.xs(vararg keyValues: Any?): GroupBy<T, G> =
+    xs(*keyValues) {
+        colsAtAnyDepth { !it.isColumnGroup() }.take(keyValues.size)
+    }
+
+public fun <T, G, C> GroupBy<T, G>.xs(vararg keyValues: C, keyColumns: ColumnsSelector<T, C>): GroupBy<T, G> =
+    xsImpl(*keyValues, keyColumns = keyColumns)
+
+// endregion
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/codeGen/CodeGenerator.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/codeGen/CodeGenerator.kt
new file mode 100644
index 000000000..3cda59f4b
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/codeGen/CodeGenerator.kt
@@ -0,0 +1,74 @@
+package org.jetbrains.dataframe.impl.codeGen
+
+import org.jetbrains.kotlinx.dataframe.codeGen.CodeWithConverter
+import org.jetbrains.kotlinx.dataframe.codeGen.DefaultReadDfMethod
+import org.jetbrains.kotlinx.dataframe.codeGen.ExtensionsCodeGenerator
+import org.jetbrains.kotlinx.dataframe.codeGen.Marker
+import org.jetbrains.kotlinx.dataframe.codeGen.MarkerVisibility
+import org.jetbrains.kotlinx.dataframe.codeGen.MarkersExtractor
+import org.jetbrains.kotlinx.dataframe.codeGen.NameNormalizer
+import org.jetbrains.kotlinx.dataframe.impl.codeGen.CodeGeneratorImpl
+import org.jetbrains.kotlinx.dataframe.impl.codeGen.FullyQualifiedNames
+import org.jetbrains.kotlinx.dataframe.impl.codeGen.ShortNames
+import org.jetbrains.kotlinx.dataframe.impl.codeGen.id
+import org.jetbrains.kotlinx.dataframe.schema.DataFrameSchema
+import kotlin.reflect.KClass
+
+public enum class InterfaceGenerationMode {
+    NoFields,
+    WithFields,
+    Enum,
+    TypeAlias,
+    None,
+}
+
+public data class CodeGenResult(val code: CodeWithConverter, val newMarkers: List<Marker>)
+
+public interface CodeGenerator : ExtensionsCodeGenerator {
+
+    public fun generate(
+        schema: DataFrameSchema,
+        name: String,
+        fields: Boolean,
+        extensionProperties: Boolean,
+        isOpen: Boolean,
+        visibility: MarkerVisibility = MarkerVisibility.IMPLICIT_PUBLIC,
+        knownMarkers: Iterable<Marker> = emptyList(),
+        readDfMethod: DefaultReadDfMethod? = null,
+        fieldNameNormalizer: NameNormalizer = NameNormalizer.id(),
+        asDataClass: Boolean = false,
+    ): CodeGenResult
+
+    public fun generate(
+        marker: Marker,
+        interfaceMode: InterfaceGenerationMode,
+        extensionProperties: Boolean,
+        readDfMethod: DefaultReadDfMethod? = null,
+    ): CodeWithConverter
+
+    public companion object {
+        public fun create(useFqNames: Boolean = true): CodeGenerator =
+            if (useFqNames) {
+                CodeGeneratorImpl(FullyQualifiedNames)
+            } else {
+                CodeGeneratorImpl(ShortNames)
+            }
+    }
+}
+
+@PublishedApi
+internal fun CodeGenerator.generate(
+    markerClass: KClass<*>,
+    interfaceMode: InterfaceGenerationMode,
+    extensionProperties: Boolean,
+): CodeWithConverter =
+    generate(
+        MarkersExtractor.get(markerClass),
+        interfaceMode,
+        extensionProperties,
+    )
+
+public inline fun <reified T> CodeGenerator.generate(
+    interfaceMode: InterfaceGenerationMode,
+    extensionProperties: Boolean,
+): CodeWithConverter = generate(T::class, interfaceMode, extensionProperties)
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/codeGen/CodeWithConverter.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/codeGen/CodeWithConverter.kt
new file mode 100644
index 000000000..a975fec2e
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/codeGen/CodeWithConverter.kt
@@ -0,0 +1,30 @@
+package org.jetbrains.kotlinx.dataframe.codeGen
+
+import org.jetbrains.kotlinx.jupyter.api.Code
+import org.jetbrains.kotlinx.jupyter.api.VariableName
+
+/**
+ * Class representing generated code declarations for a [Marker].
+ *
+ * @param declarations The generated code.
+ * @param converter Optional converter for the [Marker], such as a [org.jetbrains.kotlinx.dataframe.api.cast], often used for Jupyter.
+ */
+public data class CodeWithConverter(val declarations: Code, val converter: (VariableName) -> Code = EMPTY_CONVERTER) {
+
+    public companion object {
+        public const val EMPTY_DECLARATIONS: Code = ""
+        public val EMPTY_CONVERTER: (VariableName) -> Code = { it }
+        public val EMPTY: CodeWithConverter = CodeWithConverter(EMPTY_DECLARATIONS, EMPTY_CONVERTER)
+    }
+
+    val hasDeclarations: Boolean get() = declarations.isNotBlank()
+
+    val hasConverter: Boolean get() = converter("it").trim() != "it"
+
+    public fun with(name: VariableName): Code =
+        when {
+            !hasConverter -> declarations
+            !hasDeclarations -> converter(name)
+            else -> declarations + "\n" + converter(name)
+        }
+}
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/codeGen/DefaultReadDfMethods.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/codeGen/DefaultReadDfMethods.kt
new file mode 100644
index 000000000..6ecb10a3c
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/codeGen/DefaultReadDfMethods.kt
@@ -0,0 +1,95 @@
+package org.jetbrains.kotlinx.dataframe.codeGen
+
+import com.squareup.kotlinpoet.ClassName
+import com.squareup.kotlinpoet.FunSpec
+import com.squareup.kotlinpoet.KModifier
+import com.squareup.kotlinpoet.ParameterSpec
+import com.squareup.kotlinpoet.ParameterizedTypeName.Companion.parameterizedBy
+import com.squareup.kotlinpoet.PropertySpec
+import com.squareup.kotlinpoet.TypeSpec
+import com.squareup.kotlinpoet.asClassName
+import com.squareup.kotlinpoet.typeNameOf
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.io.MethodArguments
+
+public interface DefaultReadDfMethod {
+    public fun toDeclaration(marker: Marker, visibility: String): String
+
+    public val additionalImports: List<String>
+}
+
+// Used APIs
+private const val CAST = "cast"
+private const val VERIFY = "verify" // cast(true) is obscure, i think it's better to use named argument here
+private const val READ_CSV = "readCSV"
+private const val READ_TSV = "readTSV"
+private const val READ_JSON = "readJson"
+private const val READ_JDBC = "readJdbc"
+
+public abstract class AbstractDefaultReadMethod(
+    private val path: String?,
+    private val arguments: MethodArguments,
+    private val methodName: String,
+) : DefaultReadDfMethod {
+    override fun toDeclaration(marker: Marker, visibility: String): String {
+        val parameters = arguments.defaultValues.map {
+            ParameterSpec.builder(it.name, it.property.type)
+                .defaultValue("%N", it.property)
+                .build()
+        }
+
+        val defaultPath = path?.let {
+            PropertySpec.builder("defaultPath", typeNameOf<String>(), KModifier.CONST)
+                .initializer("%S", path)
+                .build()
+        }
+
+        val type = DataFrame::class.asClassName().parameterizedBy(ClassName("", listOf(marker.shortName)))
+
+        val arguments = parameters.joinToString(", ") { "${it.name} = ${it.name}" }
+
+        val typeSpec = TypeSpec.companionObjectBuilder()
+            .apply { if (defaultPath != null) addProperty(defaultPath) }
+            .addProperties(this.arguments.defaultValues.map { it.property })
+            .addFunction(
+                FunSpec.builder(methodName)
+                    .returns(type)
+                    .addParameter(
+                        ParameterSpec.builder("path", typeNameOf<String>())
+                            .apply {
+                                if (defaultPath != null) {
+                                    defaultValue("%N", defaultPath)
+                                }
+                            }.build(),
+                    )
+                    .addParameters(parameters)
+                    .addParameter(
+                        ParameterSpec.builder("verify", typeNameOf<Boolean?>())
+                            .defaultValue("null")
+                            .build(),
+                    )
+                    .addCode(
+                        """
+                        val df = DataFrame.$methodName(path, $arguments)
+                        return if ($VERIFY != null) df.$CAST($VERIFY = $VERIFY) else df.$CAST()
+                        """.trimIndent(),
+                    ).build(),
+            ).build()
+
+        return typeSpec.toString()
+    }
+
+    override val additionalImports: List<String> = listOf("import org.jetbrains.kotlinx.dataframe.io.$methodName")
+}
+
+internal class DefaultReadJsonMethod(path: String?, arguments: MethodArguments) :
+    AbstractDefaultReadMethod(
+        path = path,
+        arguments = arguments,
+        methodName = READ_JSON,
+    )
+
+internal class DefaultReadCsvMethod(path: String?, arguments: MethodArguments) :
+    AbstractDefaultReadMethod(path, arguments, READ_CSV)
+
+internal class DefaultReadTsvMethod(path: String?) : AbstractDefaultReadMethod(path, MethodArguments.EMPTY, READ_TSV)
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/codeGen/ExtensionsCodeGenerator.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/codeGen/ExtensionsCodeGenerator.kt
new file mode 100644
index 000000000..de874282f
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/codeGen/ExtensionsCodeGenerator.kt
@@ -0,0 +1,12 @@
+package org.jetbrains.kotlinx.dataframe.codeGen
+
+import org.jetbrains.kotlinx.dataframe.impl.codeGen.ExtensionsCodeGeneratorImpl
+import org.jetbrains.kotlinx.dataframe.impl.codeGen.ShortNames
+
+public interface ExtensionsCodeGenerator {
+    public fun generate(marker: IsolatedMarker): CodeWithConverter
+
+    public companion object {
+        public fun create(): ExtensionsCodeGenerator = ExtensionsCodeGeneratorImpl(ShortNames)
+    }
+}
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/codeGen/GeneratedField.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/codeGen/GeneratedField.kt
new file mode 100644
index 000000000..7ec248fc3
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/codeGen/GeneratedField.kt
@@ -0,0 +1,176 @@
+package org.jetbrains.kotlinx.dataframe.codeGen
+
+import org.jetbrains.kotlinx.dataframe.columns.ColumnKind
+import org.jetbrains.kotlinx.dataframe.impl.codeGen.needsQuoting
+import org.jetbrains.kotlinx.dataframe.schema.ColumnSchema
+
+public sealed interface FieldType {
+    public data class ValueFieldType(public val typeFqName: String) : FieldType
+
+    public data class FrameFieldType(
+        public val markerName: String,
+        public val nullable: Boolean,
+        public val renderAsList: Boolean,
+    ) : FieldType
+
+    public data class GroupFieldType(public val markerName: String, public val renderAsObject: Boolean) : FieldType
+}
+
+/**
+ * Returns whether the column type ends with `?` or not.
+ * NOTE: for [FieldType.FrameFieldType], the `nullable` property indicates the nullability of the frame itself, not the type of the column.
+ */
+public fun FieldType.isNullable(): Boolean =
+    when (this) {
+        is FieldType.FrameFieldType -> markerName.endsWith("?") || markerName == "*"
+        is FieldType.GroupFieldType -> markerName.endsWith("?") || markerName == "*"
+        is FieldType.ValueFieldType -> typeFqName.endsWith("?") || typeFqName == "*"
+    }
+
+/**
+ * Returns whether the column type doesn't end with `?` or whether it does.
+ * NOTE: for [FieldType.FrameFieldType], the `nullable` property indicates the nullability of the frame itself, not the type of the column.
+ */
+public fun FieldType.isNotNullable(): Boolean = !isNullable()
+
+private fun String.toNullable() = if (this.last() == '?' || this == "*") this else "$this?"
+
+/**
+ * Returns a new fieldType with the same type but with nullability in the column type.
+ * NOTE: for [FieldType.FrameFieldType], the `nullable` property indicates the nullability of the frame itself, not the type of the column.
+ */
+public fun FieldType.toNullable(): FieldType =
+    if (isNotNullable()) {
+        when (this) {
+            is FieldType.FrameFieldType -> FieldType.FrameFieldType(markerName.toNullable(), nullable, renderAsList)
+            is FieldType.GroupFieldType -> FieldType.GroupFieldType(markerName.toNullable(), renderAsObject)
+            is FieldType.ValueFieldType -> FieldType.ValueFieldType(typeFqName.toNullable())
+        }
+    } else {
+        this
+    }
+
+/**
+ * Returns a new fieldType with the same type but with nullability disabled in the column type.
+ * NOTE: for [FieldType.FrameFieldType], the `nullable` property indicates the nullability of the frame itself, not the type of the column.
+ */
+public fun FieldType.toNotNullable(): FieldType =
+    if (isNullable()) {
+        when (this) {
+            is FieldType.FrameFieldType ->
+                FieldType.FrameFieldType(
+                    markerName = markerName.let {
+                        if (it == "*") {
+                            "Any"
+                        } else {
+                            it.removeSuffix("?")
+                        }
+                    },
+                    nullable = nullable,
+                    renderAsList = renderAsList,
+                )
+
+            is FieldType.GroupFieldType ->
+                FieldType.GroupFieldType(
+                    markerName = markerName.let {
+                        if (it == "*") {
+                            "Any"
+                        } else {
+                            it.removeSuffix("?")
+                        }
+                    },
+                    renderAsObject = renderAsObject,
+                )
+
+            is FieldType.ValueFieldType ->
+                FieldType.ValueFieldType(
+                    typeFqName = typeFqName.let {
+                        if (it == "*") {
+                            "Any"
+                        } else {
+                            it.removeSuffix("?")
+                        }
+                    },
+                )
+        }
+    } else {
+        this
+    }
+
+public val FieldType.name: String
+    get() = when (this) {
+        is FieldType.FrameFieldType -> markerName
+        is FieldType.GroupFieldType -> markerName
+        is FieldType.ValueFieldType -> typeFqName
+    }
+
+public class ValidFieldName private constructor(private val identifier: String, public val needsQuote: Boolean) {
+    public val unquoted: String get() = identifier
+    public val quotedIfNeeded: String get() = if (needsQuote) "`$identifier`" else identifier
+
+    public operator fun plus(other: ValidFieldName): ValidFieldName =
+        ValidFieldName(identifier = identifier + other.identifier, needsQuote = needsQuote || other.needsQuote)
+
+    override fun toString(): String = identifier
+
+    public companion object {
+        public fun of(name: String): ValidFieldName {
+            val needsQuote = name.needsQuoting()
+            var result = name
+            if (needsQuote) {
+                result = name.replace("<", "{")
+                    .replace(">", "}")
+                    .replace("::", " - ")
+                    .replace(": ", " - ")
+                    .replace(":", " - ")
+                    .replace(".", " ")
+                    .replace("/", "-")
+                    .replace("[", "{")
+                    .replace("]", "}")
+                    .replace("`", "'")
+                    .replace(";", " ")
+                    .replace("\\", " ")
+            }
+
+            return ValidFieldName(result, needsQuote)
+        }
+    }
+}
+
+public interface BaseField {
+    public val fieldName: ValidFieldName
+    public val columnName: String
+    public val fieldType: FieldType
+}
+
+public fun BaseField.toNullable(): BaseField =
+    if (fieldType.isNullable()) {
+        this
+    } else {
+        object : BaseField {
+            override val fieldName: ValidFieldName = this@toNullable.fieldName
+            override val columnName: String = this@toNullable.columnName
+            override val fieldType: FieldType = this@toNullable.fieldType.toNullable()
+        }
+    }
+
+public fun BaseField.toNotNullable(): BaseField =
+    if (fieldType.isNotNullable()) {
+        this
+    } else {
+        object : BaseField {
+            override val fieldName: ValidFieldName = this@toNotNullable.fieldName
+            override val columnName: String = this@toNotNullable.columnName
+            override val fieldType: FieldType = this@toNotNullable.fieldType.toNotNullable()
+        }
+    }
+
+public data class GeneratedField(
+    override val fieldName: ValidFieldName,
+    override val columnName: String,
+    val overrides: Boolean,
+    val columnSchema: ColumnSchema,
+    override val fieldType: FieldType,
+) : BaseField {
+    val columnKind: ColumnKind get() = columnSchema.kind
+}
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/codeGen/Marker.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/codeGen/Marker.kt
new file mode 100644
index 000000000..d52bd6305
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/codeGen/Marker.kt
@@ -0,0 +1,121 @@
+package org.jetbrains.kotlinx.dataframe.codeGen
+
+import org.jetbrains.kotlinx.dataframe.impl.schema.DataFrameSchemaImpl
+import org.jetbrains.kotlinx.dataframe.schema.DataFrameSchema
+import kotlin.reflect.KClass
+
+public enum class MarkerVisibility {
+    INTERNAL,
+    IMPLICIT_PUBLIC,
+    EXPLICIT_PUBLIC,
+}
+
+public interface IsolatedMarker {
+    public val name: String
+    public val fields: List<BaseField>
+    public val visibility: MarkerVisibility
+
+    /**
+     * Type parameters for in front of the function or getter/setter.
+     * Like `<T : Int>` in `val <T : Int> MyType<T>.something get() = ...`.
+     */
+    public val typeParameters: String
+
+    /**
+     * Type arguments belonging to this marker.
+     * Like `<MyType>` in `MyMarker<MyType>`.
+     */
+    public val typeArguments: String
+}
+
+public abstract class AbstractMarker(typeParameters: List<String>, typeArguments: List<String>) : IsolatedMarker {
+    override val typeParameters: String = typeParameters.join()
+    override val typeArguments: String = typeArguments.join()
+
+    private fun List<String>.join() =
+        if (isEmpty()) {
+            ""
+        } else {
+            joinToString(", ", "<", ">")
+        }
+}
+
+public open class Marker(
+    override val name: String,
+    public val isOpen: Boolean,
+    override val fields: List<GeneratedField>,
+    superMarkers: List<Marker>,
+    override val visibility: MarkerVisibility,
+    typeParameters: List<String>,
+    typeArguments: List<String>,
+) : AbstractMarker(typeParameters, typeArguments) {
+
+    public val shortName: String
+        get() = name.substringAfterLast(".")
+
+    public val superMarkers: Map<String, Marker> = superMarkers.associateBy { it.name }
+
+    public val allSuperMarkers: Map<String, Marker> by lazy {
+        val result = this.superMarkers.toMutableMap()
+        this.superMarkers.forEach {
+            result.putAll(it.value.allSuperMarkers)
+        }
+        result
+    }
+
+    public val allFields: List<GeneratedField> by lazy {
+
+        val fieldsMap = mutableMapOf<String, GeneratedField>()
+        this.superMarkers.values.forEach {
+            it.allFields.forEach {
+                fieldsMap[it.fieldName.quotedIfNeeded] = it
+            }
+        }
+        fields.forEach {
+            fieldsMap[it.fieldName.quotedIfNeeded] = it
+        }
+        fieldsMap.values.toList()
+    }
+
+    public val allFieldsByColumn: Map<String, GeneratedField> by lazy {
+        allFields.associateBy { it.columnName }
+    }
+
+    public fun getField(columnName: String): GeneratedField? = allFieldsByColumn[columnName]
+
+    public fun containsColumn(columnName: String): Boolean = allFieldsByColumn.containsKey(columnName)
+
+    public val columnNames: List<String> get() = allFields.map { it.columnName }
+
+    public val schema: DataFrameSchema by lazy {
+        DataFrameSchemaImpl(allFields.associate { it.columnName to it.columnSchema })
+    }
+
+    public fun implements(schema: Marker): Boolean =
+        if (schema.name == name) true else allSuperMarkers[schema.name]?.let { it === schema } ?: false
+
+    public fun implementsAll(schemas: Iterable<Marker>): Boolean = schemas.all { implements(it) }
+
+    internal companion object {
+        operator fun invoke(
+            name: String,
+            isOpen: Boolean,
+            fields: List<GeneratedField>,
+            superMarkers: List<Marker>,
+            visibility: MarkerVisibility,
+            klass: KClass<*>,
+        ): Marker {
+            val typeParameters = klass.typeParameters.map {
+                buildString {
+                    append(it.name)
+                    if (it.upperBounds.isNotEmpty()) {
+                        append(" : ")
+                        append(it.upperBounds.joinToString(",") { it.toString() })
+                    }
+                }
+            }
+            val typeArguments = klass.typeParameters.map { it.name }
+            return Marker(name, isOpen, fields, superMarkers, visibility, typeParameters, typeArguments)
+        }
+    }
+}
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/codeGen/MarkersExtractor.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/codeGen/MarkersExtractor.kt
new file mode 100644
index 000000000..5458c9de4
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/codeGen/MarkersExtractor.kt
@@ -0,0 +1,123 @@
+package org.jetbrains.kotlinx.dataframe.codeGen
+
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.DataRow
+import org.jetbrains.kotlinx.dataframe.annotations.ColumnName
+import org.jetbrains.kotlinx.dataframe.annotations.DataSchema
+import org.jetbrains.kotlinx.dataframe.annotations.ScopeProperty
+import org.jetbrains.kotlinx.dataframe.impl.schema.getPropertyOrderFromPrimaryConstructor
+import org.jetbrains.kotlinx.dataframe.schema.ColumnSchema
+import kotlin.reflect.KClass
+import kotlin.reflect.KType
+import kotlin.reflect.full.findAnnotation
+import kotlin.reflect.full.hasAnnotation
+import kotlin.reflect.full.memberProperties
+import kotlin.reflect.full.superclasses
+import kotlin.reflect.full.withNullability
+import kotlin.reflect.jvm.jvmErasure
+import kotlin.reflect.typeOf
+
+internal fun KType.getFieldKind(): FieldKind =
+    when {
+        jvmErasure == DataFrame::class -> Frame
+        jvmErasure == List::class && (arguments[0].type?.jvmErasure?.hasAnnotation<DataSchema>() == true) -> ListToFrame
+        jvmErasure == DataRow::class -> Group
+        jvmErasure.hasAnnotation<DataSchema>() -> ObjectToGroup
+        else -> Default
+    }
+
+internal sealed interface FieldKind {
+    val shouldBeConvertedToColumnGroup: Boolean get() = false
+    val shouldBeConvertedToFrameColumn: Boolean get() = false
+}
+
+internal data object Frame : FieldKind {
+    override val shouldBeConvertedToFrameColumn: Boolean = true
+}
+
+internal data object ListToFrame : FieldKind {
+    override val shouldBeConvertedToFrameColumn: Boolean = true
+}
+
+internal data object Default : FieldKind
+
+internal data object Group : FieldKind {
+    override val shouldBeConvertedToColumnGroup: Boolean = true
+}
+
+internal data object ObjectToGroup : FieldKind {
+    override val shouldBeConvertedToColumnGroup: Boolean = true
+}
+
+private fun String.toNullable(): String = if (endsWith("?")) this else "$this?"
+
+internal object MarkersExtractor {
+
+    private val cache = mutableMapOf<Pair<KClass<*>, Boolean>, Marker>()
+
+    inline fun <reified T> get() = get(T::class)
+
+    fun get(markerClass: KClass<*>, nullableProperties: Boolean = false): Marker =
+        cache.getOrPut(Pair(markerClass, nullableProperties)) {
+            val fields = getFields(markerClass, nullableProperties)
+            val isOpen = !markerClass.isSealed &&
+                markerClass.java.isInterface &&
+                markerClass.findAnnotation<DataSchema>()?.isOpen == true
+
+            val baseSchemas = markerClass.superclasses.filter { it != Any::class }.map { get(it, nullableProperties) }
+            Marker(
+                name = markerClass.qualifiedName ?: markerClass.simpleName!!,
+                isOpen = isOpen,
+                fields = fields,
+                superMarkers = baseSchemas,
+                visibility = MarkerVisibility.IMPLICIT_PUBLIC,
+                klass = markerClass,
+            )
+        }
+
+    private fun getFields(markerClass: KClass<*>, nullableProperties: Boolean): List<GeneratedField> {
+        val order = getPropertyOrderFromPrimaryConstructor(markerClass) ?: emptyMap()
+        val structuralProperties = markerClass.memberProperties.filter { !it.hasAnnotation<ScopeProperty>() }
+        return structuralProperties.sortedBy { order[it.name] ?: Int.MAX_VALUE }.map {
+            val fieldName = ValidFieldName.of(it.name)
+            val columnName = it.findAnnotation<ColumnName>()?.name ?: fieldName.unquoted
+            val type = it.returnType
+            val fieldType: FieldType
+            val clazz = type.jvmErasure
+            val fieldKind = type.getFieldKind()
+            val columnSchema = when {
+                fieldKind.shouldBeConvertedToColumnGroup -> {
+                    val nestedType = if (clazz == DataRow::class) type.arguments[0].type ?: typeOf<Any?>() else type
+                    val marker = get(nestedType.jvmErasure, nullableProperties || type.isMarkedNullable)
+                    fieldType = FieldType.GroupFieldType(
+                        marker.name,
+                        renderAsObject = fieldKind is ObjectToGroup,
+                    )
+                    ColumnSchema.Group(marker.schema, nestedType)
+                }
+
+                fieldKind.shouldBeConvertedToFrameColumn -> {
+                    val frameType = type.arguments[0].type ?: typeOf<Any?>()
+                    val marker = get(frameType.jvmErasure, nullableProperties || type.isMarkedNullable)
+                    fieldType = FieldType.FrameFieldType(
+                        marker.name,
+                        type.isMarkedNullable || nullableProperties,
+                        renderAsList = fieldKind is ListToFrame,
+                    )
+                    ColumnSchema.Frame(marker.schema, type.isMarkedNullable, frameType)
+                }
+
+                else -> {
+                    fieldType = FieldType.ValueFieldType(
+                        if (nullableProperties) type.toString().toNullable() else type.toString(),
+                    )
+                    ColumnSchema.Value(
+                        if (nullableProperties) type.withNullability(true) else type,
+                    )
+                }
+            }
+
+            GeneratedField(fieldName, columnName, false, columnSchema, fieldType)
+        }
+    }
+}
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/codeGen/NameNormalizer.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/codeGen/NameNormalizer.kt
new file mode 100644
index 000000000..78ba98a3c
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/codeGen/NameNormalizer.kt
@@ -0,0 +1,5 @@
+package org.jetbrains.kotlinx.dataframe.codeGen
+
+public class NameNormalizer(private val f: (String) -> String) : (String) -> String by f {
+    public companion object
+}
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/codeGen/ReplCodeGenerator.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/codeGen/ReplCodeGenerator.kt
new file mode 100644
index 000000000..2b3a830aa
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/codeGen/ReplCodeGenerator.kt
@@ -0,0 +1,24 @@
+package org.jetbrains.dataframe.impl.codeGen
+
+import org.jetbrains.kotlinx.dataframe.AnyFrame
+import org.jetbrains.kotlinx.dataframe.AnyRow
+import org.jetbrains.kotlinx.dataframe.codeGen.CodeWithConverter
+import org.jetbrains.kotlinx.dataframe.impl.codeGen.ReplCodeGeneratorImpl
+import org.jetbrains.kotlinx.jupyter.api.Code
+import kotlin.reflect.KClass
+import kotlin.reflect.KProperty
+
+internal interface ReplCodeGenerator {
+
+    fun process(df: AnyFrame, property: KProperty<*>? = null): CodeWithConverter
+
+    fun process(row: AnyRow, property: KProperty<*>? = null): CodeWithConverter
+
+    fun process(markerClass: KClass<*>): Code
+
+    companion object {
+        fun create(): ReplCodeGenerator = ReplCodeGeneratorImpl()
+    }
+}
+
+internal inline fun <reified T> ReplCodeGenerator.process(): Code = process(T::class)
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/codeGen/SchemaProcessor.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/codeGen/SchemaProcessor.kt
new file mode 100644
index 000000000..ddfac8530
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/codeGen/SchemaProcessor.kt
@@ -0,0 +1,25 @@
+package org.jetbrains.kotlinx.dataframe.codeGen
+
+import org.jetbrains.kotlinx.dataframe.impl.codeGen.SchemaProcessorImpl
+import org.jetbrains.kotlinx.dataframe.schema.DataFrameSchema
+
+internal interface SchemaProcessor {
+
+    val generatedMarkers: List<Marker>
+
+    val namePrefix: String
+
+    fun process(
+        schema: DataFrameSchema,
+        isOpen: Boolean,
+        visibility: MarkerVisibility = MarkerVisibility.IMPLICIT_PUBLIC,
+    ): Marker
+
+    companion object {
+        fun create(
+            namePrefix: String,
+            existingMarkers: Iterable<Marker> = emptyList(),
+            fieldNameNormalizer: (String) -> String = { it },
+        ): SchemaProcessorImpl = SchemaProcessorImpl(existingMarkers, namePrefix, fieldNameNormalizer)
+    }
+}
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/columns/CellKind.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/columns/CellKind.kt
new file mode 100644
index 000000000..a545c2d96
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/columns/CellKind.kt
@@ -0,0 +1,15 @@
+package org.jetbrains.kotlinx.dataframe.columns
+
+/**
+ *	Represents special kinds of elements that can be found within a Column.
+ *	This is similar to the [ColumnKind], but it applies to specific elements of the Column.
+ *	Its main use is to provide metadata during serialization for visualization within the KTNB plugin.
+ */
+internal enum class CellKind {
+    /**
+     * Represents a cell kind within a Column that is specifically convertible to a DataFrame.
+     */
+    DataFrameConvertable {
+        override fun toString(): String = "DataFrameConvertable"
+    },
+}
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/columns/ColumnAccessor.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/columns/ColumnAccessor.kt
new file mode 100644
index 000000000..4536755c6
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/columns/ColumnAccessor.kt
@@ -0,0 +1,27 @@
+package org.jetbrains.kotlinx.dataframe.columns
+
+import org.jetbrains.kotlinx.dataframe.DataColumn
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.DataRow
+import org.jetbrains.kotlinx.dataframe.api.column
+import org.jetbrains.kotlinx.dataframe.api.columnGroup
+import org.jetbrains.kotlinx.dataframe.api.frameColumn
+import kotlin.reflect.KProperty
+
+/**
+ * Combination of [column path][path] and [column type][T].
+ *
+ * Used to retrieve [DataColumn] from [DataFrame] or value from [DataRow].
+ *
+ * Can be created by [column], [columnGroup] or [frameColumn] delegates.
+ *
+ * @param T Expected [type][DataColumn.type] of values in the column
+ */
+public interface ColumnAccessor<out T> : ColumnReference<T> {
+
+    public override operator fun getValue(thisRef: Any?, property: KProperty<*>): ColumnAccessor<T> = this
+
+    public operator fun <C> get(column: ColumnReference<C>): ColumnAccessor<C>
+
+    override fun rename(newName: String): ColumnAccessor<T>
+}
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/columns/ColumnKind.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/columns/ColumnKind.kt
new file mode 100644
index 000000000..d6c326075
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/columns/ColumnKind.kt
@@ -0,0 +1,13 @@
+package org.jetbrains.kotlinx.dataframe.columns
+
+public enum class ColumnKind {
+    Value {
+        override fun toString(): String = "ValueColumn"
+    },
+    Group {
+        override fun toString(): String = "ColumnGroup"
+    },
+    Frame {
+        override fun toString(): String = "FrameColumn"
+    },
+}
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/columns/ColumnPath.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/columns/ColumnPath.kt
new file mode 100644
index 000000000..3db5677ee
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/columns/ColumnPath.kt
@@ -0,0 +1,116 @@
+package org.jetbrains.kotlinx.dataframe.columns
+
+import org.jetbrains.kotlinx.dataframe.AnyRow
+import org.jetbrains.kotlinx.dataframe.DataColumn
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl
+import org.jetbrains.kotlinx.dataframe.impl.columns.ColumnAccessorImpl
+import org.jetbrains.kotlinx.dataframe.impl.owner
+
+/**
+ * Path to a [column][DataColumn] in [DataFrame].
+ *
+ * Stores a list of [column names][DataColumn.name] that are used to retrieve columns through a chain of [column groups][ColumnGroup].
+ */
+public data class ColumnPath(val path: List<String>) :
+    List<String> by path,
+    ColumnAccessor<Any?> {
+
+    public constructor(name: String) : this(listOf(name))
+
+    public fun drop(size: Int): ColumnPath = ColumnPath(path.drop(size))
+
+    public fun parent(): ColumnPath? = if (path.isEmpty()) null else dropLast(1)
+
+    /**
+     * Returns a shortened [ColumnPath] without the last [size] elements.
+     *
+     * NOTE: If called from the [ColumnsSelectionDsl], you might be looking for [ColumnsSelectionDsl.dropLastChildren]
+     * instead.
+     */
+    public fun dropLast(size: Int = 1): ColumnPath = ColumnPath(path.dropLast(size))
+
+    /**
+     * Returns a shortened [ColumnPath] without the first [size] elements.
+     *
+     * NOTE: If called from the [ColumnsSelectionDsl], you might be looking for [ColumnsSelectionDsl.dropChildren]
+     * instead.
+     */
+    public fun dropFirst(size: Int = 1): ColumnPath = ColumnPath(path.drop(size))
+
+    public operator fun plus(name: String): ColumnPath = ColumnPath(path + name)
+
+    public operator fun plus(otherPath: ColumnPath): ColumnPath = ColumnPath(path + otherPath.path)
+
+    public operator fun plus(otherPath: Iterable<String>): ColumnPath = ColumnPath(path + otherPath)
+
+    /**
+     * Returns a shortened [ColumnPath] containing just the first [first] elements.
+     *
+     * NOTE: If called from the [ColumnsSelectionDsl], you might be looking for [ColumnsSelectionDsl.takeCols]
+     * instead.
+     */
+    public fun take(first: Int): ColumnPath = ColumnPath(path.take(first))
+
+    public fun replaceLast(name: String): ColumnPath =
+        ColumnPath(if (path.size < 2) listOf(name) else path.dropLast(1) + name)
+
+    /**
+     * Returns a shortened [ColumnPath] containing just the last [last] elements.
+     *
+     * NOTE: If called from the [ColumnsSelectionDsl], you might be looking for [ColumnsSelectionDsl.takeLast]
+     * instead.
+     */
+    public fun takeLast(last: Int): ColumnPath = ColumnPath(path.takeLast(last))
+
+    override fun path(): ColumnPath = this
+
+    override fun name(): String = path.last()
+
+    val columnName: String get() = name()
+
+    val parentName: String? get() = if (path.size > 1) path[path.size - 2] else null
+
+    override fun rename(newName: String): ColumnPath = ColumnPath(path.dropLast(1) + newName)
+
+    override fun getValue(row: AnyRow): Any? = row.owner[this][row.index()]
+
+    override fun getValueOrNull(row: AnyRow): Any? = row.owner.getColumnOrNull(this)?.get(row.index())
+
+    override fun toString(): String = path.toString()
+
+    public fun joinToString(separator: String = "/"): String = path.joinToString(separator)
+
+    override fun <C> get(column: ColumnReference<C>): ColumnAccessor<C> = ColumnAccessorImpl(this + column.path())
+}
+
+/**
+ * Drops the overlapping start of the child path with respect to the parent path, and returns the resulting ColumnPath.
+ *
+ * For example:
+ * ```kt
+ * val parentPath = pathOf("a", "b", "c")
+ * val childPath = pathOf("a", "b", "c", "d", "e")
+ *
+ * childPath.dropStartWrt(parentPath) // returns pathOf("d", "e")
+ * ```
+ *
+ * @param otherPath The parent path to compare against.
+ * @return The resulting ColumnPath after dropping the overlapping start.
+ */
+internal fun ColumnPath.dropStartWrt(otherPath: ColumnPath): ColumnPath {
+    val first = dropOverlappingStartOfChild(parent = otherPath, child = this)
+    return ColumnPath(first)
+}
+
+internal fun <T> dropOverlappingStartOfChild(parent: List<T>, child: List<T>): List<T> {
+    var indexToRemoveTill = 0
+    for (i in child.indices) {
+        val subFirst = child.subList(0, i + 1)
+        val sufficientSubSecond = parent.subList(maxOf(0, parent.size - (i + 1)), parent.size)
+        if (subFirst == sufficientSubSecond) {
+            indexToRemoveTill = i + 1
+        }
+    }
+    return child.subList(indexToRemoveTill, child.size)
+}
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/columns/ColumnReference.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/columns/ColumnReference.kt
new file mode 100644
index 000000000..768c6858e
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/columns/ColumnReference.kt
@@ -0,0 +1,48 @@
+package org.jetbrains.kotlinx.dataframe.columns
+
+import org.jetbrains.kotlinx.dataframe.AnyFrame
+import org.jetbrains.kotlinx.dataframe.AnyRow
+import org.jetbrains.kotlinx.dataframe.DataColumn
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.DataRow
+import org.jetbrains.kotlinx.dataframe.api.name
+import org.jetbrains.kotlinx.dataframe.impl.columnName
+import org.jetbrains.kotlinx.dataframe.impl.columns.RenamedColumnReference
+import org.jetbrains.kotlinx.dataframe.impl.columns.addPath
+import org.jetbrains.kotlinx.dataframe.impl.columns.getColumn
+import kotlin.reflect.KProperty
+
+/**
+ * Entity that can retrieve [DataColumn] from [DataFrame] or value from [DataRow].
+ *
+ * Base interface for [DataColumn] and [ColumnAccessor].
+ * @param C Expected [type][DataColumn.type] of values in the column
+ */
+public interface ColumnReference<out C> : SingleColumn<C> {
+
+    public operator fun getValue(thisRef: Any?, property: KProperty<*>): ColumnReference<C> =
+        renamedReference(property.columnName)
+
+    public fun name(): String
+
+    public fun rename(newName: String): ColumnReference<C>
+
+    public fun path(): ColumnPath = ColumnPath(name)
+
+    public fun getValue(row: AnyRow): C = resolveFor(row.df())!![row.index()]
+
+    public fun getValueOrNull(row: AnyRow): C? = resolveFor(row.df())?.get(row.index())
+
+    override fun resolveSingle(context: ColumnResolutionContext): ColumnWithPath<C>? =
+        context.df
+            .getColumn<C>(path(), context.unresolvedColumnsPolicy)
+            ?.addPath(path())
+}
+
+internal fun <C> ColumnReference<C>.renamedReference(newName: String): ColumnReference<C> =
+    RenamedColumnReference(this, newName)
+
+internal fun ColumnReference<*>.shortPath() = ColumnPath(name)
+
+internal fun <C> ColumnReference<C>.resolveFor(df: AnyFrame): ColumnWithPath<C>? =
+    resolveSingle(ColumnResolutionContext(df, UnresolvedColumnsPolicy.Skip))
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/columns/ColumnSet.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/columns/ColumnSet.kt
new file mode 100644
index 000000000..046b9c2bd
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/columns/ColumnSet.kt
@@ -0,0 +1,37 @@
+package org.jetbrains.kotlinx.dataframe.columns
+
+import org.jetbrains.kotlinx.dataframe.DataColumn
+import org.jetbrains.kotlinx.dataframe.DataRow
+import org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl
+import org.jetbrains.kotlinx.dataframe.api.asSingleColumn
+
+/**
+ * ## ColumnSet
+ *
+ * Entity that can be resolved into a list of [columns][DataColumn].
+ * Just like [SingleColumn], this is a [ColumnsResolver].
+ *
+ * @see [SingleColumn]
+ * @see [ColumnsResolver]
+ */
+public interface ColumnSet<out C> : ColumnsResolver<C>
+
+internal fun <C> ColumnsResolver<C>.asColumnSet(): ColumnSet<C> =
+    when (this) {
+        is ColumnSet<C> -> this
+
+        else -> object : ColumnSet<C> {
+            override fun resolve(context: ColumnResolutionContext): List<ColumnWithPath<C>> =
+                this@asColumnSet.resolve(context)
+        }
+    }
+
+@Suppress("UNCHECKED_CAST")
+@PublishedApi
+internal fun <C> SingleColumn<C>.asColumnSet(): ColumnSet<C> =
+    when (this) {
+        is ColumnSet<*> -> this as ColumnSet<C>
+        else -> object : ColumnSet<C>, SingleColumn<C> by this {}
+    }
+
+internal fun <C> ColumnsSelectionDsl<C>.asColumnSet(): ColumnSet<DataRow<C>> = asSingleColumn().asColumnSet()
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/columns/ColumnWithPath.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/columns/ColumnWithPath.kt
new file mode 100644
index 000000000..1ed1c1a6e
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/columns/ColumnWithPath.kt
@@ -0,0 +1,63 @@
+package org.jetbrains.kotlinx.dataframe.columns
+
+import org.jetbrains.kotlinx.dataframe.DataColumn
+import org.jetbrains.kotlinx.dataframe.api.asColumnGroup
+import org.jetbrains.kotlinx.dataframe.api.isColumnGroup
+import org.jetbrains.kotlinx.dataframe.impl.columns.addParentPath
+import org.jetbrains.kotlinx.dataframe.impl.columns.addPath
+import org.jetbrains.kotlinx.dataframe.impl.columns.depth
+import kotlin.reflect.KProperty
+
+public interface ColumnWithPath<out T> : DataColumn<T> {
+    public val data: DataColumn<T>
+
+    public val path: ColumnPath
+
+    public val name: String get() = name()
+
+    public val parentName: String? get() = path.parentName
+
+    public fun depth(): Int = path.depth()
+
+    /**
+     * Casts this column to a [ColumnGroup] and returns a column with the specified [accessor] or null if it
+     * can't be found.
+     */
+    public fun <C> getCol(accessor: ColumnReference<C>): ColumnWithPath<C>? =
+        asColumnGroup().getColumnOrNull(accessor)?.addPath(path + accessor.path())
+
+    /**
+     * Casts this column to a [ColumnGroup] and returns a column with the specified [name] or null if it
+     * can't be found.
+     */
+    public fun getCol(name: String): ColumnWithPath<Any?>? = asColumnGroup().getColumnOrNull(name)?.addParentPath(path)
+
+    /**
+     * Casts this column to a [ColumnGroup] and returns a column with the specified [index] or null if it
+     * can't be found.
+     */
+    public fun getCol(index: Int): ColumnWithPath<Any?>? = asColumnGroup().getColumnOrNull(index)?.addParentPath(path)
+
+    /**
+     * Casts this column to a [ColumnGroup] and returns a column with the specified [accessor] or null if it
+     * can't be found.
+     */
+    public fun <C> getCol(accessor: KProperty<C>): ColumnWithPath<C>? =
+        asColumnGroup().getColumnOrNull(accessor)?.addParentPath(path)
+
+    /**
+     * Returns all ("children") columns in this column if it's a group, else it returns an empty list.
+     */
+    public fun cols(): List<ColumnWithPath<Any?>> =
+        if (isColumnGroup()) {
+            data.asColumnGroup().columns().map { it.addParentPath(path) }
+        } else {
+            emptyList()
+        }
+
+    override fun path(): ColumnPath = path
+
+    override fun rename(newName: String): ColumnWithPath<T>
+}
+
+public val <T> ColumnWithPath<T>.depth: Int get() = path.depth()
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/columns/ColumnsResolver.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/columns/ColumnsResolver.kt
new file mode 100644
index 000000000..700d76fbb
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/columns/ColumnsResolver.kt
@@ -0,0 +1,42 @@
+package org.jetbrains.kotlinx.dataframe.columns
+
+import org.jetbrains.kotlinx.dataframe.ColumnsSelector
+import org.jetbrains.kotlinx.dataframe.DataColumn
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.impl.columns.TransformableColumnSet
+import org.jetbrains.kotlinx.dataframe.impl.columns.TransformableSingleColumn
+import org.jetbrains.kotlinx.dataframe.impl.columns.transform
+
+/**
+ * ## ColumnsResolver
+ * Entity that can be resolved into a list of [columns][DataColumn].
+ *
+ * Used as a return type of [ColumnsSelector].
+ *
+ * Implemented by [SingleColumn] and [ColumnSet].
+ *
+ * @param C common type of resolved columns
+ * @see [SingleColumn]
+ * @see [ColumnSet]
+ * @see [TransformableColumnSet]
+ * @see [TransformableSingleColumn]
+ */
+public sealed interface ColumnsResolver<out C> {
+
+    /**
+     * Resolves this [ColumnsResolver] as a [List]<[ColumnWithPath]<[C]>>.
+     * In many cases this function [transforms][ColumnsResolver.transform] a parent [ColumnsResolver] to reach
+     * the current [ColumnsResolver] result.
+     */
+    public fun resolve(context: ColumnResolutionContext): List<ColumnWithPath<C>>
+}
+
+public class ColumnResolutionContext internal constructor(
+    internal val df: DataFrame<*>,
+    internal val unresolvedColumnsPolicy: UnresolvedColumnsPolicy,
+) {
+
+    public val allowMissingColumns: Boolean = unresolvedColumnsPolicy != UnresolvedColumnsPolicy.Fail
+}
+
+internal enum class UnresolvedColumnsPolicy { Fail, Skip, Create }
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/columns/FrameColumn.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/columns/FrameColumn.kt
new file mode 100644
index 000000000..70b988740
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/columns/FrameColumn.kt
@@ -0,0 +1,23 @@
+package org.jetbrains.kotlinx.dataframe.columns
+
+import org.jetbrains.kotlinx.dataframe.DataColumn
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.schema.DataFrameSchema
+
+/**
+ * Column that stores values of type [DataFrame]
+ *
+ * @param T schema marker of contained dataframes. See [DataFrame] for details.
+ */
+public interface FrameColumn<out T> : DataColumn<DataFrame<T>> {
+
+    public val schema: Lazy<DataFrameSchema>
+
+    override fun distinct(): FrameColumn<T>
+
+    override fun kind(): ColumnKind = ColumnKind.Frame
+
+    override fun rename(newName: String): FrameColumn<T>
+
+    override fun get(indices: Iterable<Int>): FrameColumn<T>
+}
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/columns/SingleColumn.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/columns/SingleColumn.kt
new file mode 100644
index 000000000..e8d0e048b
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/columns/SingleColumn.kt
@@ -0,0 +1,33 @@
+package org.jetbrains.kotlinx.dataframe.columns
+
+import org.jetbrains.kotlinx.dataframe.DataColumn
+import org.jetbrains.kotlinx.dataframe.api.isColumnGroup
+import org.jetbrains.kotlinx.dataframe.impl.columns.TransformableColumnSet
+import org.jetbrains.kotlinx.dataframe.impl.columns.TransformableSingleColumn
+
+/**
+ * ## SingleColumn
+ * Entity that can be [resolved][resolveSingle] into a single [DataColumn].
+ *
+ * @param C Column [type][BaseColumn.type] of resolved column.
+ * @see [ColumnsResolver]
+ * @see [TransformableColumnSet]
+ * @see [TransformableSingleColumn]
+ */
+public interface SingleColumn<out C> : ColumnsResolver<C> {
+
+    override fun resolve(context: ColumnResolutionContext): List<ColumnWithPath<C>> =
+        resolveSingle(context)
+            ?.let { listOf(it) }
+            ?: emptyList()
+
+    public fun resolveSingle(context: ColumnResolutionContext): ColumnWithPath<C>?
+}
+
+public fun ColumnsResolver<*>.isSingleColumn(): Boolean = this is SingleColumn<*>
+
+/**
+ * Returns true if [this] is a [SingleColumn] and [cols] consists of a single column group.
+ */
+public fun ColumnsResolver<*>.isSingleColumnWithGroup(cols: List<ColumnWithPath<*>>): Boolean =
+    isSingleColumn() && cols.singleOrNull()?.isColumnGroup() == true
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/columns/ValueColumn.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/columns/ValueColumn.kt
new file mode 100644
index 000000000..a1d898429
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/columns/ValueColumn.kt
@@ -0,0 +1,25 @@
+package org.jetbrains.kotlinx.dataframe.columns
+
+import org.jetbrains.kotlinx.dataframe.DataColumn
+import kotlin.reflect.KProperty
+
+/**
+ * Column that stores values.
+ *
+ * @param T - type of values
+ */
+public interface ValueColumn<out T> : DataColumn<T> {
+
+    override fun kind(): ColumnKind = ColumnKind.Value
+
+    override fun distinct(): ValueColumn<T>
+
+    override fun get(indices: Iterable<Int>): ValueColumn<T>
+
+    override fun rename(newName: String): ValueColumn<T>
+
+    override operator fun getValue(thisRef: Any?, property: KProperty<*>): ValueColumn<T> =
+        super.getValue(thisRef, property) as ValueColumn<T>
+
+    public override operator fun get(range: IntRange): ValueColumn<T>
+}
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/columns/constructors.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/columns/constructors.kt
new file mode 100644
index 000000000..4cc2e9b7c
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/columns/constructors.kt
@@ -0,0 +1,66 @@
+package org.jetbrains.kotlinx.dataframe.columns
+
+import org.jetbrains.kotlinx.dataframe.api.toColumnAccessor
+import org.jetbrains.kotlinx.dataframe.impl.asList
+import org.jetbrains.kotlinx.dataframe.impl.columns.ColumnsList
+import kotlin.reflect.KProperty
+
+// region toColumnSet
+
+// region Array
+
+public fun Array<out ColumnsResolver<*>>.toColumnSet(): ColumnSet<Any?> = ColumnsList(asList())
+
+@JvmName("toColumnSetString")
+public fun Array<out String>.toColumnSet(): ColumnSet<Any?> = map { it.toColumnAccessor() }.toColumnSet()
+
+@JvmName("toColumnSetColumnPath")
+public fun Array<out ColumnPath>.toColumnSet(): ColumnSet<Any?> = map { it.toColumnAccessor() }.toColumnSet()
+
+public fun <C> Array<out KProperty<C>>.toColumnSet(): ColumnSet<C> = map { it.toColumnAccessor() }.toColumnSet()
+
+@JvmName("toColumnSetC")
+public fun <C> Array<out ColumnsResolver<C>>.toColumnSet(): ColumnSet<C> = ColumnsList(asList())
+
+public fun <C> Array<out ColumnReference<C>>.toColumnSet(): ColumnSet<C> = asIterable().toColumnSet()
+
+// endregion
+
+// region Iterable
+
+public fun Iterable<ColumnsResolver<*>>.toColumnSet(): ColumnSet<Any?> = ColumnsList(asList())
+
+@JvmName("toColumnSetString")
+public fun Iterable<String>.toColumnSet(): ColumnSet<Any?> = map { it.toColumnAccessor() }.toColumnSet()
+
+@JvmName("toColumnSetColumnPath")
+public fun Iterable<ColumnPath>.toColumnSet(): ColumnSet<Any?> = map { it.toColumnAccessor() }.toColumnSet()
+
+@JvmName("toColumnSetKProperty")
+public fun <C> Iterable<KProperty<C>>.toColumnSet(): ColumnSet<C> = map { it.toColumnAccessor() }.toColumnSet()
+
+@JvmName("toColumnSetC")
+public fun <C> Iterable<ColumnsResolver<C>>.toColumnSet(): ColumnSet<C> = ColumnsList(toList())
+
+@JvmName("toColumnSetColumnReference")
+public fun <C> Iterable<ColumnReference<C>>.toColumnSet(): ColumnSet<C> = ColumnsList(toList())
+
+// endregion
+
+// endregion
+
+// region toColumnSetOf
+
+// region Array
+
+public fun <C> Array<out String>.toColumnsSetOf(): ColumnSet<C> = toColumnSet() as ColumnSet<C>
+
+// endregion
+
+// region Iterable
+
+public fun <C> Iterable<String>.toColumnsSetOf(): ColumnSet<C> = toColumnSet() as ColumnSet<C>
+
+// endregion
+
+// endregion
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/dataTypes/IFRAME.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/dataTypes/IFRAME.kt
new file mode 100644
index 000000000..547544576
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/dataTypes/IFRAME.kt
@@ -0,0 +1,24 @@
+package org.jetbrains.kotlinx.dataframe.dataTypes
+
+import java.net.URL
+
+public data class IFRAME(
+    val src: String,
+    val border: Boolean = false,
+    val width: Int? = null,
+    val height: Int? = null,
+) {
+    public constructor(
+        src: URL,
+        border: Boolean = false,
+        width: Int? = null,
+        height: Int? = null,
+    ) : this(src.toString(), border, width, height)
+
+    override fun toString(): String =
+        """<iframe src="$src" frameborder=${if (border) 1 else 0}${
+            width?.let { " width=$it" } ?: ""
+        }${
+            height?.let { " height=$it" } ?: ""
+        }/>"""
+}
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/dataTypes/IMG.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/dataTypes/IMG.kt
new file mode 100644
index 000000000..15ca32585
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/dataTypes/IMG.kt
@@ -0,0 +1,28 @@
+package org.jetbrains.kotlinx.dataframe.dataTypes
+
+import java.net.URL
+
+public data class IMG(
+    val src: String,
+    val width: Int? = null,
+    val height: Int? = null,
+    val maxWidth: Int? = null,
+    val maxHeight: Int? = null,
+) {
+    public constructor(
+        src: URL,
+        width: Int? = null,
+        height: Int? = null,
+        maxWidth: Int? = null,
+        maxHeight: Int? = null,
+    ) : this(src.toString(), width, height, maxWidth, maxHeight)
+
+    override fun toString(): String {
+        val style = StringBuilder()
+        if (width != null) style.append("width:${width}px;")
+        if (height != null) style.append("height:${height}px;")
+        if (maxWidth != null) style.append("max-width:${maxWidth}px;")
+        if (maxHeight != null) style.append("max-height:${maxHeight}px;")
+        return """<img src="$src" style="$style"}/>"""
+    }
+}
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/AccessApi.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/AccessApi.kt
new file mode 100644
index 000000000..8a7f1a8c7
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/AccessApi.kt
@@ -0,0 +1,133 @@
+package org.jetbrains.kotlinx.dataframe.documentation
+
+/**
+ * ## Access APIs
+ *
+ * By nature, data frames are dynamic objects, column labels depend on the input source and also new columns could be added
+ * or deleted while wrangling. Kotlin, in contrast, is a statically typed language and all types are defined and verified
+ * ahead of execution. That's why creating a flexible, handy, and, at the same time, safe API to a data frame is tricky.
+ *
+ * In `Kotlin DataFrame` we provide four different ways to access columns, and, while they're essentially different, they
+ * look pretty similar in the data wrangling DSL. These include:
+ * - [Extension Properties API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi.ExtensionPropertiesApi]
+ * - [KProperties API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi.KPropertiesApi]
+ * - [Column Accessors API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi.ColumnAccessorsApi]
+ * - [String API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi.StringApi]
+ *
+ * For more information: [See Access APIs on the documentation website.](https://kotlin.github.io/dataframe/apilevels.html)
+ *
+ */
+internal interface AccessApi {
+
+    /**
+     * - [Extension Properties API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi.ExtensionPropertiesApi]
+     * - [KProperties API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi.KPropertiesApi]
+     * - [Column Accessors API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi.ColumnAccessorsApi]
+     * - [String API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi.StringApi]
+     */
+    interface AnyApiLinks
+
+    /**
+     * String API.
+     * In this [AccessApi], columns are accessed by a [String] representing their name.
+     * Type-checking is done at runtime, name-checking too.
+     *
+     * For more information: [See String API on the documentation website.](https://kotlin.github.io/dataframe/stringapi.html)
+     *
+     * For example:
+     * ```kotlin
+     * DataFrame.read("titanic.csv")
+     *     .add("lastName") { "name"<String>().split(",").last() }
+     *     .dropNulls("age")
+     *     .filter {
+     *         "survived"<Boolean>() &&
+     *             "home"<String>().endsWith("NY") &&
+     *             "age"<Int>() in 10..20
+     *     }
+     * ```
+     */
+    interface StringApi
+
+    /** [String API][StringApi] */
+    interface StringApiLink
+
+    /**
+     * Column Accessors API.
+     * In this [AccessApi], every column has a descriptor;
+     * a variable that represents its name and type.
+     *
+     * For more information: [See Column Accessors API on the documentation website.](https://kotlin.github.io/dataframe/columnaccessorsapi.html)
+     *
+     * For example:
+     * ```kotlin
+     * val survived by column<Boolean>()
+     * val home by column<String>()
+     * val age by column<Int?>()
+     * val name by column<String>()
+     * val lastName by column<String>()
+     *
+     * DataFrame.read("titanic.csv")
+     *     .add(lastName) { name().split(",").last() }
+     *     .dropNulls { age }
+     *     .filter { survived() && home().endsWith("NY") && age()!! in 10..20 }
+     * ```
+     */
+    interface ColumnAccessorsApi
+
+    /** [Column Accessors API][AccessApi.ColumnAccessorsApi] */
+    interface ColumnAccessorsApiLink
+
+    /**
+     * KProperties API.
+     * In this [AccessApi], columns accessed by the
+     * [`KProperty`](https://kotlinlang.org/docs/reflection.html#property-references)
+     * of some class.
+     * The name and type of column should match the name and type of property, respectively.
+     *
+     * For more information: [See KProperties API on the documentation website.](https://kotlin.github.io/dataframe/kpropertiesapi.html)
+     *
+     * For example:
+     * ```kotlin
+     * data class Passenger(
+     *     val survived: Boolean,
+     *     val home: String,
+     *     val age: Int,
+     *     val lastName: String
+     * )
+     *
+     * val passengers = DataFrame.read("titanic.csv")
+     *     .add(Passenger::lastName) { "name"<String>().split(",").last() }
+     *     .dropNulls(Passenger::age)
+     *     .filter {
+     *         it[Passenger::survived] &&
+     *             it[Passenger::home].endsWith("NY") &&
+     *             it[Passenger::age] in 10..20
+     *     }
+     *     .toListOf<Passenger>()
+     * ```
+     */
+    interface KPropertiesApi
+
+    /** [KProperties API][KPropertiesApi] */
+    interface KPropertiesApiLink
+
+    /**
+     * Extension Properties API.
+     * In this [AccessApi], extension access properties are generated based on the dataframe schema.
+     * The name and type of properties are inferred from the name and type of the corresponding columns.
+     *
+     * For more information: [See Extension Properties API on the documentation website.](https://kotlin.github.io/dataframe/extensionpropertiesapi.html)
+     *
+     * For example:
+     * ```kotlin
+     * val df /* : AnyFrame */ = DataFrame.read("titanic.csv")
+     * ```
+     */
+    interface ExtensionPropertiesApi
+
+    /** [Extension Properties API][ExtensionPropertiesApi] */
+    interface ExtensionPropertiesApiLink
+}
+
+/** [Access API][AccessApi] */
+internal interface AccessApiLink
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/ColumnExpression.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/ColumnExpression.kt
new file mode 100644
index 000000000..06a793657
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/ColumnExpression.kt
@@ -0,0 +1,31 @@
+package org.jetbrains.kotlinx.dataframe.documentation
+
+import org.jetbrains.kotlinx.dataframe.api.AddDsl
+import org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl
+import org.jetbrains.kotlinx.dataframe.api.CreateDataFrameDsl
+import org.jetbrains.kotlinx.dataframe.api.expr
+
+/**
+ * ## Column Expression
+ * In many DSLs, the lambda `expr {}` can be used to
+ * create a new column by defining an expression to fill up each row.
+ *
+ * These DSLs include (but are not limited to):
+ * [The Add DSL][AddDsl.expr], [The Columns Selection DSL][ColumnsSelectionDsl.expr], and
+ * [The Create DataFrame DSL][CreateDataFrameDsl.expr].
+ *
+ * `expr {}` behaves like a mapping statement, iterating over the object it's called on.
+ */
+internal interface ColumnExpression {
+
+    /**
+     * ## Column Expression
+     * Create a temporary new column by defining an expression to fill up each row.
+     *
+     * See [Column Expression][org.jetbrains.kotlinx.dataframe.documentation.ColumnExpression] for more information.
+     */
+    interface CommonDocs
+}
+
+/** [Column Expression][ColumnExpression] */
+internal interface ColumnExpressionLink
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/DslGrammar.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/DslGrammar.kt
new file mode 100644
index 000000000..85f62a95c
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/DslGrammar.kt
@@ -0,0 +1,35 @@
+package org.jetbrains.kotlinx.dataframe.documentation
+
+/**
+ * ## DSL Grammar
+ *
+ * If you've come across notations like **`a(`** `(`**`b`**` | [`**`c, .. `**`] )` **`)`**
+ * either in the KDocs or on the website and would like some further explanation
+ * for what it means, you've come to the right place.
+ *
+ * The notation we use is _roughly_ based on [EBNF](https://en.wikipedia.org/wiki/Extended_Backus%E2%80%93Naur_form)
+ * with some slight deviations to improve readability in the context of Kotlin.
+ * The grammars are also almost always decorated with highlighted code snippets allowing you to click around and explore!
+ *
+ * ### Symbols
+ * - '**`bold text`**' : literal Kotlin notation, e.g. '**`myFunction`**', '**`{ }`**', '**`[ ]`**', etc.
+ * - '`normal text`' : Definitions or types existing either just in the grammar or in the library itself.
+ * - '`:`' : Separates a definition from its type, e.g. '`name: `[String]'.
+ * - '`|`', '`/`' : Separates multiple possibilities, often clarified with `()` brackets or spaces, e.g. '**`a`**` ( `**`b`**` | `**`c`**` )`'.
+ * - '`[ ... ]`' : Indicates that the contents are optional, e.g. '`[ `**`a`**` ]`'. Careful to not confuse this with **bold** Kotlin brackets **`[]`**.
+ *    - NOTE: sometimes **`function`**` [`**`{ }`**`]` notation is used to indicate that the function has an optional lambda. This function will still require **`()`** brackets to work without lambda.
+ * - '**`,`**` ..`' : Indicates that the contents can be repeated with multiple arguments of the same type(s), e.g. '`[ `**`a,`**` .. ]`'.
+ * - '`( ... )`' : Indicates grouping, e.g. '`( `**`a`**` | `**`b`**` )` **`c`**'.
+ *
+ * No other symbols of [EBNF](https://en.wikipedia.org/wiki/Extended_Backus%E2%80%93Naur_form) are used.
+ *
+ * &nbsp;&nbsp;&nbsp;&nbsp;
+ *
+ * Note that the grammar is not always 100% accurate to keep the readability acceptable.
+ * Always use your common sense reading it and if you're unsure, try out the function yourself or check
+ * the source code :).
+ */
+public interface DslGrammar
+
+/** [(What is this notation?)][DslGrammar] */
+internal interface DslGrammarLink
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/DslGrammarTemplateColumnsSelectionDsl.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/DslGrammarTemplateColumnsSelectionDsl.kt
new file mode 100644
index 000000000..59bc1e55c
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/DslGrammarTemplateColumnsSelectionDsl.kt
@@ -0,0 +1,327 @@
+package org.jetbrains.kotlinx.dataframe.documentation
+
+import org.jetbrains.kotlinx.dataframe.ColumnFilter
+import org.jetbrains.kotlinx.dataframe.ColumnSelector
+import org.jetbrains.kotlinx.dataframe.ColumnsSelector
+import org.jetbrains.kotlinx.dataframe.DataRow
+import org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl
+import org.jetbrains.kotlinx.dataframe.columns.ColumnKind
+import org.jetbrains.kotlinx.dataframe.columns.ColumnSet
+import org.jetbrains.kotlinx.dataframe.columns.ColumnsResolver
+
+/*
+ * This template is to be used in displaying the Usage / DSL grammar
+ * of each individual ColumnsSelectionDsl function group, as well as the entire
+ * thing itself.
+ *
+ * See an example of how to use this template at [UsageTemplateColumnsSelectionDsl.UsageTemplateExample]
+ */
+public interface DslGrammarTemplateColumnsSelectionDsl {
+
+    /**
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * [(What is this notation?)][org.jetbrains.kotlinx.dataframe.documentation.DslGrammar]
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  ### Definitions:
+     *
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  ### What can be called directly in the [Columns Selection DSL][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl]:
+     *
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  ### What can be called on a [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]:
+     *
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  [`columnSet`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ColumnSetDef]
+     *
+     *
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  ### What can be called on a [Column Group (reference)][DslGrammarTemplate.ColumnGroupDef]:
+     *
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  [`columnGroup`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ColumnGroupDef]
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     */
+    public interface DslGrammarTemplate {
+
+        // region parts
+
+        // Can be set to nothing to disable the definitions part
+        public interface DefinitionsPart
+
+        // Can be set to nothing to disable the plain dsl part
+        public interface PlainDslPart
+
+        // Can be set to nothing to disable the column set part
+        public interface ColumnSetPart
+
+        // Can be set to nothing to disable the column group part
+        public interface ColumnGroupPart
+
+        // endregion
+
+        // region Template arguments
+
+        // What to put in definitions part aside from the default part.
+        public interface DefinitionsArg
+
+        // What to put in the plain dsl part. Does not need indents.
+        public interface PlainDslFunctionsArg
+
+        // What to put in the column set part. Needs indents.
+        public interface ColumnSetFunctionsArg
+
+        // What to put in the column group part. Needs indents.
+        public interface ColumnGroupFunctionsArg
+
+        // endregion
+
+        // region Definitions for at the top of the template
+
+        /**
+         * `columnGroupReference: `[`String`][String]`  |  `[`KProperty`][kotlin.reflect.KProperty]`<*> | `[`ColumnPath`][org.jetbrains.kotlinx.dataframe.columns.ColumnPath]
+         */
+        public interface ColumnGroupNoSingleColumnDef
+
+        /** `colSelector: `[`ColumnSelector`][ColumnSelector] */
+        public interface ColumnSelectorDef
+
+        /** `colsSelector: `[`ColumnsSelector`][ColumnsSelector] */
+        public interface ColumnsSelectorDef
+
+        /**
+         * `column: `[`ColumnAccessor`][org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor]`  |  `[`String`][String]`  | `[`KProperty`][kotlin.reflect.KProperty]`<*> | `[`ColumnPath`][org.jetbrains.kotlinx.dataframe.columns.ColumnPath]
+         */
+        public interface ColumnDef
+
+        /**
+         * `columnGroup: `[`SingleColumn`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]`<`[`DataRow`][org.jetbrains.kotlinx.dataframe.DataRow]`<*>> | `[`String`][String]`  |  `[`KProperty`][kotlin.reflect.KProperty]`<* | `[`DataRow`][DataRow]`<*>> | `[`ColumnPath`][org.jetbrains.kotlinx.dataframe.columns.ColumnPath]
+         */
+        public interface ColumnGroupDef
+
+        /** `columnNoAccessor: `[`String`][String]`  |  `[`KProperty`][kotlin.reflect.KProperty]`<*> | `[`ColumnPath`][org.jetbrains.kotlinx.dataframe.columns.ColumnPath] */
+        public interface ColumnNoAccessorDef
+
+        /** `columnOrSet: `[`column`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ColumnDef]`  |  `[`columnSet`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ColumnSetDef] */
+        public interface ColumnOrColumnSetDef
+
+        /** `columnSet: `[`ColumnSet`][ColumnSet]`<*>` */
+        public interface ColumnSetDef
+
+        /** `columnsResolver: `[`ColumnsResolver`][ColumnsResolver] */
+        public interface ColumnsResolverDef
+
+        /** `condition: `[`ColumnFilter`][ColumnFilter] */
+        public interface ConditionDef
+
+        /** `expression: `[Column Expression][org.jetbrains.kotlinx.dataframe.documentation.ColumnExpression] */
+        public interface ColumnExpressionDef
+
+        /** `ignoreCase: `[`Boolean`][Boolean] */
+        public interface IgnoreCaseDef
+
+        /** `index: `[`Int`][Int] */
+        public interface IndexDef
+
+        /** `indexRange: `[`IntRange`][IntRange] */
+        public interface IndexRangeDef
+
+        /** `infer: `[`Infer`][org.jetbrains.kotlinx.dataframe.api.Infer] */
+        public interface InferDef
+
+        /** `kind: `[`ColumnKind`][ColumnKind] */
+        public interface ColumnKindDef
+
+        /** `kType: `[`KType`][kotlin.reflect.KType] */
+        public interface KTypeDef
+
+        /** `name: `[`String`][String] */
+        public interface NameDef
+
+        /** `number: `[`Int`][Int] */
+        public interface NumberDef
+
+        /** `regex: `[`Regex`][Regex] */
+        public interface RegexDef
+
+        /**
+         * `singleColumn: `[`SingleColumn`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]`<`[`DataRow`][org.jetbrains.kotlinx.dataframe.DataRow]`<*>>`
+         */
+        public interface SingleColumnDef
+
+        /** `T: Column type` */
+        public interface ColumnTypeDef
+
+        /** `text: `[`String`][String] */
+        public interface TextDef
+
+        // endregion
+
+        // region References to the definitions
+
+        /** [`columnGroupReference`][ColumnGroupNoSingleColumnDef] */
+        public interface ColumnGroupNoSingleColumnRef
+
+        /** [`colSelector`][ColumnSelectorDef] */
+        public interface ColumnSelectorRef
+
+        /** [`colsSelector`][ColumnsSelectorDef] */
+        public interface ColumnsSelectorRef
+
+        /** [`column`][ColumnDef] */
+        public interface ColumnRef
+
+        /** [`columnGroup`][ColumnGroupDef] */
+        public interface ColumnGroupRef
+
+        /** [`columnNoAccessor`][ColumnNoAccessorDef] */
+        public interface ColumnNoAccessorRef
+
+        /** [`columnOrSet`][ColumnOrColumnSetDef] */
+        public interface ColumnOrColumnSetRef
+
+        /** [`columnSet`][ColumnSetDef] */
+        public interface ColumnSetRef
+
+        /** [`columnsResolver`][ColumnsResolverDef] */
+        public interface ColumnsResolverRef
+
+        /** [`condition`][ConditionDef] */
+        public interface ConditionRef
+
+        /** [`expression`][ColumnExpressionDef] */
+        public interface ColumnExpressionRef
+
+        /** [`ignoreCase`][IgnoreCaseDef] */
+        public interface IgnoreCaseRef
+
+        /** [`index`][IndexDef] */
+        public interface IndexRef
+
+        /** [`indexRange`][IndexRangeDef] */
+        public interface IndexRangeRef
+
+        /** [`infer`][InferDef] */
+        public interface InferRef
+
+        /** [`kind`][ColumnKindDef] */
+        public interface ColumnKindRef
+
+        /** [`kType`][KTypeDef] */
+        public interface KTypeRef
+
+        /** [`name`][NameDef] */
+        public interface NameRef
+
+        /** [`number`][NumberDef] */
+        public interface NumberRef
+
+        /** [`regex`][RegexDef] */
+        public interface RegexRef
+
+        /** [`singleColumn`][SingleColumnDef] */
+        public interface SingleColumnRef
+
+        /** [`T`][ColumnTypeDef] */
+        public interface ColumnTypeRef
+
+        /** [`text`][TextDef] */
+        public interface TextRef
+
+        // endregion
+    }
+
+    /**
+     * ## MyFunction Example Usage
+     *
+     *
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * [(What is this notation?)][org.jetbrains.kotlinx.dataframe.documentation.DslGrammar]
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  ### Definitions:
+     *  `columnSet: `[`ColumnSet`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]`<*>`
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  `columnGroup: `[`SingleColumn`][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]`<`[`DataRow`][org.jetbrains.kotlinx.dataframe.DataRow]`<*>> | `[`String`][String]`  |  `[`KProperty`][kotlin.reflect.KProperty]`<* | `[`DataRow`][org.jetbrains.kotlinx.dataframe.DataRow]`<*>> | `[`ColumnPath`][org.jetbrains.kotlinx.dataframe.columns.ColumnPath]
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  `number: `[`Int`][Int]
+     *
+     *
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  ### What can be called on a [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]:
+     *
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  [`columnSet`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ColumnSetDef]
+     *
+     *  &nbsp;&nbsp;&nbsp;&nbsp;__`.`__[**`example`**][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.first]**`(`**`[`[`number`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.NumberDef]`]`**`)`**
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  ### What can be called on a [Column Group (reference)][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ColumnGroupDef]:
+     *
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     *  [`columnGroup`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.ColumnGroupDef]
+     *
+     *  &nbsp;&nbsp;&nbsp;&nbsp;__`.`__[**`colsExample`**][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.first]**`(`**`[`[`number`][org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate.NumberDef]`]`**`)`**
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     */
+    public interface UsageTemplateExample {
+
+        /** __`.`__[**`example`**][ColumnsSelectionDsl.first] */
+        public interface ColumnSetName
+
+        /** __`.`__[**`colsExample`**][ColumnsSelectionDsl.first] */
+        public interface ColumnGroupName
+    }
+}
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/ExpressionsGivenRow.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/ExpressionsGivenRow.kt
new file mode 100644
index 000000000..74b044d49
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/ExpressionsGivenRow.kt
@@ -0,0 +1,101 @@
+package org.jetbrains.kotlinx.dataframe.documentation
+
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.DataRow
+import org.jetbrains.kotlinx.dataframe.api.AddDataRow
+import org.jetbrains.kotlinx.dataframe.api.Convert
+import org.jetbrains.kotlinx.dataframe.api.Update
+import org.jetbrains.kotlinx.dataframe.api.add
+import org.jetbrains.kotlinx.dataframe.api.insert
+import org.jetbrains.kotlinx.dataframe.api.map
+import org.jetbrains.kotlinx.dataframe.api.notNull
+import org.jetbrains.kotlinx.dataframe.api.with
+import org.jetbrains.kotlinx.dataframe.RowExpression as DfRowExpression
+import org.jetbrains.kotlinx.dataframe.RowValueExpression as DfRowValueExpression
+
+/**
+ * ## Expressions Given Row
+ * Expressing values using a "Row Expression" ([See Row Expressions on the documentation website.](https://kotlin.github.io/dataframe/datarow.html#row-expressions))
+ * can occur in the following two types of operations:
+ *
+ * - Providing a new value for every selected cell given the row of that cell ([Row Expression][org.jetbrains.kotlinx.dataframe.documentation.ExpressionsGivenRow.RowExpression.WithExample]),
+ * for instance in [map][DataFrame.map], [add][DataFrame.add], and [insert][DataFrame.insert]
+ * (using [RowExpression][DfRowExpression]).
+ *
+ * - Providing a new value for every selected cell given the row of that cell and its previous value ([Row Value Expression][org.jetbrains.kotlinx.dataframe.documentation.ExpressionsGivenRow.RowValueExpression.WithExample]),
+ * for instance in [update.with][Update.with], and [convert.notNull][Convert.notNull]
+ * (using [RowValueExpression][DfRowValueExpression]).
+ *
+ * NOTE:
+ *
+ * [update with][org.jetbrains.kotlinx.dataframe.api.Update.with]- and [add][org.jetbrains.kotlinx.dataframe.api.add]-like expressions use [AddDataRow][org.jetbrains.kotlinx.dataframe.api.AddDataRow] instead of [DataRow][org.jetbrains.kotlinx.dataframe.DataRow] as the DSL's receiver type.
+ * This is an extension to [RowValueExpression][org.jetbrains.kotlinx.dataframe.RowValueExpression] and
+ * [RowExpression][org.jetbrains.kotlinx.dataframe.RowExpression] that provides access to
+ * the modified/generated value of the preceding row ([AddDataRow.newValue][org.jetbrains.kotlinx.dataframe.api.AddDataRow.newValue]).
+ *
+ * A [Row Expression][org.jetbrains.kotlinx.dataframe.documentation.ExpressionsGivenRow.RowExpression.WithExample] is similar to a [Row Condition][org.jetbrains.kotlinx.dataframe.documentation.SelectingRows] but that expects a [Boolean] as result.
+ */
+internal interface ExpressionsGivenRow {
+
+    /*
+     * The key for a @set that will define the operation name for the examples below.
+     * Make sure to [alias][your examples].
+     */
+    interface OperationArg
+
+    // Using <code>` notation to not create double `` when including
+
+    interface SetDefaultOperationArg
+
+    /**
+     * [update with][org.jetbrains.kotlinx.dataframe.api.Update.with]- and [add][org.jetbrains.kotlinx.dataframe.api.add]-like expressions use [AddDataRow] instead of [DataRow] as the DSL's receiver type.
+     * This is an extension to [RowValueExpression][DfRowValueExpression] and
+     * [RowExpression][DfRowExpression] that provides access to
+     * the modified/generated value of the preceding row ([AddDataRow.newValue]).
+     */
+    interface AddDataRowNote
+
+    /** Provide a new value for every selected cell given its row using a [row expression][DfRowExpression]. */
+    interface RowExpression {
+
+        /**
+         * Provide a new value for every selected cell given its row using a [row expression][org.jetbrains.kotlinx.dataframe.RowExpression].
+         *
+         * For example:
+         *
+         * `df.`<code>`operation`</code>` { name.firstName + " " + name.lastName }`
+         *
+         * `df.`<code>`operation`</code>` { 2021 - age }`
+         *
+         */
+        interface WithExample
+    }
+
+    /** [Row Expression][RowExpression.WithExample] */
+    interface RowExpressionLink
+
+    /** Provide a new value for every selected cell given its row and its previous value using a
+     * [row value expression][DfRowValueExpression].
+     */
+    interface RowValueExpression {
+
+        /**
+         * Provide a new value for every selected cell given its row and its previous value using a
+         * [row value expression][org.jetbrains.kotlinx.dataframe.RowValueExpression].
+         *
+         * For example:
+         *
+         * `df.`<code>`operation`</code>` { name.firstName + " from " + it }`
+         *
+         * `df.`<code>`operation`</code>` { it.uppercase() }`
+         *
+         */
+        interface WithExample
+    }
+
+    /** [Row Value Expression][RowValueExpression.WithExample] */
+    interface RowValueExpressionLink
+}
+
+/** [Row Expression][ExpressionsGivenRow] */
+internal interface RowExpressionsLink
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/ExpressionsGivenRowAndColumn.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/ExpressionsGivenRowAndColumn.kt
new file mode 100644
index 000000000..d619b3686
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/ExpressionsGivenRowAndColumn.kt
@@ -0,0 +1,45 @@
+package org.jetbrains.kotlinx.dataframe.documentation
+
+import org.jetbrains.kotlinx.dataframe.DataColumn
+import org.jetbrains.kotlinx.dataframe.api.mean
+import org.jetbrains.kotlinx.dataframe.RowColumnExpression as DfRowColumnExpression
+
+/**
+ * ## Expressions Given Row and Column
+ * Expressing values using a "Row-Column Expression" can occur exclusively in a
+ * [Row Column Expression][org.jetbrains.kotlinx.dataframe.documentation.ExpressionsGivenRowAndColumn.RowColumnExpression].
+ */
+internal interface ExpressionsGivenRowAndColumn {
+
+    /*
+     * The key for a @set that will define the operation name for the examples below.
+     * Make sure to [alias][your examples].
+     */
+    interface OperationArg
+
+    // Using <code>` notation to not create double `` when including
+
+    interface SetDefaultOperationArg
+
+    /** Provide a new value for every selected cell given both its row and column using a [row-column expression][DfRowColumnExpression]. */
+    interface RowColumnExpression {
+
+        /**
+         * Provide a new value for every selected cell given both its row and column using a [row-column expression][org.jetbrains.kotlinx.dataframe.RowColumnExpression].
+         *
+         * For example:
+         *
+         * `df.`<code>`operation`</code>` { row, col ->`
+         *
+         * &nbsp;&nbsp;&nbsp;&nbsp;`row.age / col.`[mean][DataColumn.mean]`(skipNA = true)`
+         *
+         * `}`
+         *
+         *
+         */
+        interface WithExample
+    }
+
+    /** [Row Column Expression][RowColumnExpression] */
+    interface RowColumnExpressionLink
+}
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/NA.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/NA.kt
new file mode 100644
index 000000000..d8f9d513a
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/NA.kt
@@ -0,0 +1,20 @@
+package org.jetbrains.kotlinx.dataframe.documentation
+
+import org.jetbrains.kotlinx.dataframe.api.dropNA
+import org.jetbrains.kotlinx.dataframe.api.fillNA
+
+/**
+ * ## `NA`
+ * `NA` in Dataframe can be seen as "[NaN] or `null`".
+ *
+ * [Floats][Float] or [Doubles][Double] can be represented as [Float.NaN] or [Double.NaN], respectively,
+ * in cases where a mathematical operation is undefined, such as dividing by zero.
+ *
+ * You can also use [fillNA][fillNA] to replace `NAs` in certain columns with a given value or expression
+ * or [dropNA][dropNA] to drop rows with `NAs` in them.
+ *
+ * For more information: [See `NA` on the documentation website.](https://kotlin.github.io/dataframe/nanAndNa.html#na)
+ *
+ * @see NaN
+ */
+internal interface NA
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/NaN.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/NaN.kt
new file mode 100644
index 000000000..bcb89b72c
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/NaN.kt
@@ -0,0 +1,18 @@
+package org.jetbrains.kotlinx.dataframe.documentation
+
+import org.jetbrains.kotlinx.dataframe.api.dropNaNs
+import org.jetbrains.kotlinx.dataframe.api.fillNaNs
+
+/**
+ * ## `NaN`
+ * [Floats][Float] or [Doubles][Double] can be represented as [Float.NaN] or [Double.NaN], respectively,
+ * in cases where a mathematical operation is undefined, such as dividing by zero.
+ *
+ * You can also use [fillNaNs][fillNaNs] to replace `NaNs` in certain columns with a given value or expression
+ * or [dropNaNs][dropNaNs] to drop rows with `NaNs` in them.
+ *
+ * For more information: [See `NaN` on the documentation website.](https://kotlin.github.io/dataframe/nanAndNa.html#nan)
+ *
+ * @see NA
+ */
+internal interface NaN
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/SelectingColumns.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/SelectingColumns.kt
new file mode 100644
index 000000000..ad11b0f85
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/SelectingColumns.kt
@@ -0,0 +1,292 @@
+package org.jetbrains.kotlinx.dataframe.documentation
+
+import org.jetbrains.kotlinx.dataframe.ColumnSelector
+import org.jetbrains.kotlinx.dataframe.ColumnsSelector
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl
+import org.jetbrains.kotlinx.dataframe.api.colsOf
+import org.jetbrains.kotlinx.dataframe.api.column
+import org.jetbrains.kotlinx.dataframe.api.fillNulls
+import org.jetbrains.kotlinx.dataframe.api.gather
+import org.jetbrains.kotlinx.dataframe.api.select
+import org.jetbrains.kotlinx.dataframe.api.update
+import org.jetbrains.kotlinx.dataframe.columns.ColumnReference
+import org.jetbrains.kotlinx.dataframe.columns.ColumnSet
+import org.jetbrains.kotlinx.dataframe.columns.ColumnsResolver
+import org.jetbrains.kotlinx.dataframe.columns.SingleColumn
+import org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns.ColumnAccessors
+import org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns.ColumnNames
+import org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns.Dsl
+import org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns.KProperties
+import kotlin.reflect.KProperty
+
+/** [Selecting Columns][SelectingColumns] */
+internal interface SelectingColumnsLink
+
+/**
+ * ## Selecting Columns
+ * Selecting columns for various operations (including but not limited to
+ * [DataFrame.select], [DataFrame.update], [DataFrame.gather], and [DataFrame.fillNulls])
+ * can be done in the following ways:
+ * ### 1. [Columns Selection DSL][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns.Dsl.WithExample]
+ * Select or express columns using the [Columns Selection DSL][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl].
+ * (Any (combination of) [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+ *
+ * This DSL is initiated by a [Columns Selector][org.jetbrains.kotlinx.dataframe.ColumnsSelector] lambda,
+ * which operates in the context of the [Columns Selection DSL][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl] and
+ * expects you to return a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn] or [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] (so, a [ColumnsResolver][org.jetbrains.kotlinx.dataframe.columns.ColumnsResolver]).
+ * This is an entity formed by calling any (combination) of the functions
+ * in the DSL that is or can be resolved into one or more columns.
+ *
+ * #### NOTE:
+ * While you can use the [String API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi.StringApi] and [KProperties API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi.KPropertiesApi]
+ * in this DSL directly with any function, they are NOT valid return types for the
+ * [Columns Selector][org.jetbrains.kotlinx.dataframe.ColumnsSelector] lambda. You'd need to turn them into a [ColumnReference][org.jetbrains.kotlinx.dataframe.columns.ColumnReference] first, for instance
+ * with a function like [`col("name")`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.col].
+ *
+ * ### Check out: [Columns Selection DSL Grammar][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.DslGrammar]
+ *
+ * &nbsp;&nbsp;&nbsp;&nbsp;
+ *
+ * [See Column Selectors on the documentation website.](https://kotlin.github.io/dataframe/columnselectors.html)
+ *
+ * #### For example:
+ *
+ * `df.`<code>`operation`</code>` { length `[and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and]` age }`
+ *
+ * `df.`<code>`operation`</code>`  {  `[cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`(1..5) }`
+ *
+ * `df.`<code>`operation`</code>`  {  `[colsOf][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[Double][Double]`>() }`
+ *
+ *
+ * #### NOTE: There's also a 'single column' variant used sometimes: [Column Selection DSL][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns.DslSingle.WithExample].
+ * ### 2. [Column names][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns.ColumnNames.WithExample]
+ * Select columns using their [column names][String]
+ * ([String API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi.StringApi]).
+ *
+ * #### For example:
+ *
+ * `df.`<code>`operation`</code>`("length", "age")`
+ *
+ * ### 3. [Column references][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns.ColumnAccessors.WithExample]
+ * Select columns using [column accessors][org.jetbrains.kotlinx.dataframe.columns.ColumnReference]
+ * ([Column Accessors API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi.ColumnAccessorsApi]).
+ *
+ * #### For example:
+ *
+ * `val length by `[column][org.jetbrains.kotlinx.dataframe.api.column]`<`[Double][Double]`>()`
+ *
+ * `val age by `[column][org.jetbrains.kotlinx.dataframe.api.column]`<`[Double][Double]`>()`
+ *
+ * `df.`<code>`operation`</code>`(length, age)`
+ *
+ * ### 4. [KProperties][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns.KProperties.WithExample]
+ * Select columns using [KProperties][KProperty] ([KProperties API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi.KPropertiesApi]).
+ *
+ * #### For example:
+ * ```kotlin
+ * data class Person(val length: Double, val age: Double)
+ * ```
+ *
+ * `df.`<code>`operation`</code>`(Person::length, Person::age)`
+ *
+ */
+internal interface SelectingColumns {
+
+    /*
+     * The key for a @set that will define the operation name for the examples below.
+     * Make sure to [alias][your examples].
+     */
+    interface OperationArg
+
+    // Using <code>` notation to not create double `` when including
+
+    interface SetDefaultOperationArg
+
+    /**
+     * Select or express columns using the [Columns Selection DSL][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl].
+     * (Any (combination of) [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+     *
+     * This DSL is initiated by a [Columns Selector][ColumnsSelector] lambda,
+     * which operates in the context of the [Columns Selection DSL][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl] and
+     * expects you to return a [SingleColumn] or [ColumnSet] (so, a [ColumnsResolver]).
+     * This is an entity formed by calling any (combination) of the functions
+     * in the DSL that is or can be resolved into one or more columns.
+     *
+     * #### NOTE:
+     * While you can use the [String API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi.StringApi] and [KProperties API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi.KPropertiesApi]
+     * in this DSL directly with any function, they are NOT valid return types for the
+     * [Columns Selector][ColumnsSelector] lambda. You'd need to turn them into a [ColumnReference] first, for instance
+     * with a function like [`col("name")`][ColumnsSelectionDsl.col].
+     *
+     * ### Check out: [Columns Selection DSL Grammar][ColumnsSelectionDsl.DslGrammar]
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * [See Column Selectors on the documentation website.](https://kotlin.github.io/dataframe/columnselectors.html)
+     */
+    interface Dsl {
+
+        /**
+         * Select or express columns using the [Columns Selection DSL][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl].
+         * (Any (combination of) [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+         *
+         * This DSL is initiated by a [Columns Selector][org.jetbrains.kotlinx.dataframe.ColumnsSelector] lambda,
+         * which operates in the context of the [Columns Selection DSL][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl] and
+         * expects you to return a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn] or [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] (so, a [ColumnsResolver][org.jetbrains.kotlinx.dataframe.columns.ColumnsResolver]).
+         * This is an entity formed by calling any (combination) of the functions
+         * in the DSL that is or can be resolved into one or more columns.
+         *
+         * #### NOTE:
+         * While you can use the [String API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi.StringApi] and [KProperties API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi.KPropertiesApi]
+         * in this DSL directly with any function, they are NOT valid return types for the
+         * [Columns Selector][org.jetbrains.kotlinx.dataframe.ColumnsSelector] lambda. You'd need to turn them into a [ColumnReference][org.jetbrains.kotlinx.dataframe.columns.ColumnReference] first, for instance
+         * with a function like [`col("name")`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.col].
+         *
+         * ### Check out: [Columns Selection DSL Grammar][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.DslGrammar]
+         *
+         * &nbsp;&nbsp;&nbsp;&nbsp;
+         *
+         * [See Column Selectors on the documentation website.](https://kotlin.github.io/dataframe/columnselectors.html)
+         *
+         * #### For example:
+         *
+         * `df.`<code>`operation`</code>` { length `[and][ColumnsSelectionDsl.and]` age }`
+         *
+         * `df.`<code>`operation`</code>`  {  `[cols][ColumnsSelectionDsl.cols]`(1..5) }`
+         *
+         * `df.`<code>`operation`</code>`  {  `[colsOf][ColumnsSelectionDsl.colsOf]`<`[Double][Double]`>() }`
+         *
+         *
+         */
+        interface WithExample
+    }
+
+    /** [Columns Selection DSL][Dsl.WithExample] */
+    interface DslLink
+
+    /**
+     * Select or express a single column using the Column Selection DSL.
+     * (Any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+     *
+     * This DSL is initiated by a [Column Selector][ColumnSelector] lambda,
+     * which operates in context of the [Column Selection DSL][org.jetbrains.kotlinx.dataframe.api.ColumnSelectionDsl] and
+     * expects you to return a [SingleColumn].
+     * This is an entity formed by calling any (combination) of the functions
+     * in the DSL that is or can be resolved into a single column.
+     *
+     * #### NOTE:
+     * While you can use the [String API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi.StringApi] and [KProperties API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi.KPropertiesApi]
+     * in this DSL directly with any function, they are NOT valid return types for the
+     * [Column Selector][ColumnSelector]/[Columns Selector][ColumnsSelector] lambda. You'd need to turn them into a [ColumnReference] first, for instance
+     * with a function like [`col("name")`][ColumnsSelectionDsl.col].
+     *
+     *
+     * &nbsp;&nbsp;&nbsp;&nbsp;
+     *
+     * [See Column Selectors on the documentation website.](https://kotlin.github.io/dataframe/columnselectors.html)
+     */
+    interface DslSingle {
+
+        /**
+         * Select or express a single column using the Column Selection DSL.
+         * (Any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+         *
+         * This DSL is initiated by a [Column Selector][org.jetbrains.kotlinx.dataframe.ColumnSelector] lambda,
+         * which operates in context of the [Column Selection DSL][org.jetbrains.kotlinx.dataframe.api.ColumnSelectionDsl] and
+         * expects you to return a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn].
+         * This is an entity formed by calling any (combination) of the functions
+         * in the DSL that is or can be resolved into a single column.
+         *
+         * #### NOTE:
+         * While you can use the [String API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi.StringApi] and [KProperties API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi.KPropertiesApi]
+         * in this DSL directly with any function, they are NOT valid return types for the
+         * [Column Selector][org.jetbrains.kotlinx.dataframe.ColumnSelector]/[Columns Selector][org.jetbrains.kotlinx.dataframe.ColumnsSelector] lambda. You'd need to turn them into a [ColumnReference][org.jetbrains.kotlinx.dataframe.columns.ColumnReference] first, for instance
+         * with a function like [`col("name")`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.col].
+         *
+         *
+         * &nbsp;&nbsp;&nbsp;&nbsp;
+         *
+         * [See Column Selectors on the documentation website.](https://kotlin.github.io/dataframe/columnselectors.html)
+         *
+         * #### For example:
+         *
+         * `df.`<code>`operation`</code>` { length }`
+         *
+         * `df.`<code>`operation`</code>`  {  `[col][ColumnsSelectionDsl.col]`(1) }`
+         *
+         * `df.`<code>`operation`</code>`  {  `[colsOf][ColumnsSelectionDsl.colsOf]`<`[Double][Double]`>().`[first][ColumnsSelectionDsl.first]`() }`
+         *
+         */
+        interface WithExample
+    }
+
+    /** [Column Selection DSL][DslSingle.WithExample] */
+    interface DslSingleLink
+
+    /**
+     * Select columns using their [column names][String]
+     * ([String API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi.StringApi]).
+     */
+    interface ColumnNames {
+
+        /**
+         * Select columns using their [column names][String]
+         * ([String API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi.StringApi]).
+         *
+         * #### For example:
+         *
+         * `df.`<code>`operation`</code>`("length", "age")`
+         *
+         */
+        interface WithExample
+    }
+
+    /** [Column names][ColumnNames.WithExample] */
+    interface ColumnNamesLink
+
+    /**
+     * Select columns using [column accessors][ColumnReference]
+     * ([Column Accessors API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi.ColumnAccessorsApi]).
+     */
+    interface ColumnAccessors {
+
+        /**
+         * Select columns using [column accessors][org.jetbrains.kotlinx.dataframe.columns.ColumnReference]
+         * ([Column Accessors API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi.ColumnAccessorsApi]).
+         *
+         * #### For example:
+         *
+         * `val length by `[column][column]`<`[Double][Double]`>()`
+         *
+         * `val age by `[column][column]`<`[Double][Double]`>()`
+         *
+         * `df.`<code>`operation`</code>`(length, age)`
+         *
+         */
+        interface WithExample
+    }
+
+    /** [Column references][ColumnAccessors.WithExample] */
+    interface ColumnAccessorsLink
+
+    /** Select columns using [KProperties][KProperty] ([KProperties API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi.KPropertiesApi]). */
+    interface KProperties {
+
+        /**
+         * Select columns using [KProperties][KProperty] ([KProperties API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi.KPropertiesApi]).
+         *
+         * #### For example:
+         * ```kotlin
+         * data class Person(val length: Double, val age: Double)
+         * ```
+         *
+         * `df.`<code>`operation`</code>`(Person::length, Person::age)`
+         *
+         */
+        interface WithExample
+    }
+
+    /** [KProperties][KProperties.WithExample] */
+    interface KPropertiesLink
+}
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/SelectingRows.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/SelectingRows.kt
new file mode 100644
index 000000000..2c32ce1de
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/SelectingRows.kt
@@ -0,0 +1,87 @@
+package org.jetbrains.kotlinx.dataframe.documentation
+
+import org.jetbrains.kotlinx.dataframe.RowFilter
+import org.jetbrains.kotlinx.dataframe.RowValueFilter
+import org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl
+import org.jetbrains.kotlinx.dataframe.api.count
+import org.jetbrains.kotlinx.dataframe.api.diff
+import org.jetbrains.kotlinx.dataframe.api.drop
+import org.jetbrains.kotlinx.dataframe.api.filter
+import org.jetbrains.kotlinx.dataframe.api.first
+import org.jetbrains.kotlinx.dataframe.api.format
+import org.jetbrains.kotlinx.dataframe.api.gather
+import org.jetbrains.kotlinx.dataframe.api.update
+import org.jetbrains.kotlinx.dataframe.index
+
+/**
+ * ## Selecting Rows
+ * Selecting rows that satisfy a "Row Condition" ([See Row Conditions on the documentation website.](https://kotlin.github.io/dataframe/datarow.html#row-conditions))
+ * can occur in the following two types of operations:
+ * - Selecting entire rows ([Entire-Row Condition][org.jetbrains.kotlinx.dataframe.documentation.SelectingRows.EntireRowCondition.WithExample]), for instance in [filter], [drop], [first], and [count]
+ * (using [RowFilter]).
+ * - Selecting parts of rows using a `where` operation after selecting columns ([Row-Value Condition][org.jetbrains.kotlinx.dataframe.documentation.SelectingRows.RowValueCondition.WithExample]),
+ * such as with [update], [gather], and [format]
+ * (using [RowValueFilter]).
+ *
+ * A Row Condition is similar to a [Row Expression][org.jetbrains.kotlinx.dataframe.documentation.ExpressionsGivenRow] but expects a [Boolean] as result.
+ */
+internal interface SelectingRows {
+
+    /*
+     * The key for a @set that will define the operation name for the examples below.
+     * Make sure to [alias][your examples].
+     */
+    interface FirstOperationArg
+
+    /*
+     * The key for a @set that will define the operation name for the examples below.
+     * Make sure to [alias][your examples].
+     */
+    interface SecondOperationArg
+
+    interface SetDefaultOperationArg
+
+    /** [Entire-Row Condition][EntireRowCondition.WithExample] */
+    interface RowConditionLink
+
+    /** Filter or find rows to operate on using a [row filter][RowFilter]. */
+    interface EntireRowCondition {
+
+        /**
+         * Filter or find rows to operate on using a [row filter][org.jetbrains.kotlinx.dataframe.RowFilter].
+         *
+         * For example:
+         *
+         * `df.`operation` { `[index][index]`() % 2 == 0 }`
+         *
+         * `df.`operation` { `[diff][diff]` { age } == 0 }`
+         *
+         */
+        interface WithExample
+    }
+
+    /** [Row-Value Condition][RowValueCondition.WithExample] */
+    interface RowValueConditionLink
+
+    /** Filter or find rows to operate on after [selecting columns][SelectingColumns] using a
+     * [row value filter][RowValueFilter].
+     */
+    interface RowValueCondition {
+
+        /**
+         * Filter or find rows to operate on after [selecting columns][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns] using a
+         * [row value filter][org.jetbrains.kotlinx.dataframe.RowValueFilter].
+         *
+         * For example:
+         *
+         * `df.`operation` { length }.`where` { it > 10.0 }`
+         *
+         * `df.`operation` { `[cols][ColumnsSelectionDsl.cols]`(1..5) }.`where` { `[index][index]`() > 4 && city != "Paris" }`
+         *
+         */
+        interface WithExample
+    }
+}
+
+/** [Row Condition][SelectingRows] */
+internal interface RowConditionLink
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/utils.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/utils.kt
new file mode 100644
index 000000000..7d9563405
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/utils.kt
@@ -0,0 +1,94 @@
+package org.jetbrains.kotlinx.dataframe.documentation
+
+import kotlin.annotation.AnnotationTarget.ANNOTATION_CLASS
+import kotlin.annotation.AnnotationTarget.CLASS
+import kotlin.annotation.AnnotationTarget.CONSTRUCTOR
+import kotlin.annotation.AnnotationTarget.FIELD
+import kotlin.annotation.AnnotationTarget.FILE
+import kotlin.annotation.AnnotationTarget.FUNCTION
+import kotlin.annotation.AnnotationTarget.LOCAL_VARIABLE
+import kotlin.annotation.AnnotationTarget.PROPERTY
+import kotlin.annotation.AnnotationTarget.PROPERTY_GETTER
+import kotlin.annotation.AnnotationTarget.PROPERTY_SETTER
+import kotlin.annotation.AnnotationTarget.TYPE
+import kotlin.annotation.AnnotationTarget.TYPEALIAS
+import kotlin.annotation.AnnotationTarget.VALUE_PARAMETER
+
+/**
+ *
+ * &nbsp;&nbsp;&nbsp;&nbsp;
+ *
+ */
+internal interface LineBreak
+
+/** &nbsp; */
+internal interface QuarterIndent
+
+/** &nbsp;&nbsp; */
+internal interface HalfIndent
+
+/** &nbsp;&nbsp;&nbsp;&nbsp; */
+internal interface Indent
+
+/** &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; */
+internal interface DoubleIndent
+
+/** &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; */
+internal interface TripleIndent
+
+/** &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; */
+internal interface QuadrupleIndent
+
+/**
+ * Any `Documentable` annotated with this annotation will be excluded from the generated sources by
+ * the documentation processor.
+ *
+ * **NOTE: DO NOT RENAME!**
+ */
+@Target(
+    CLASS,
+    ANNOTATION_CLASS,
+    PROPERTY,
+    FIELD,
+    LOCAL_VARIABLE,
+    VALUE_PARAMETER,
+    CONSTRUCTOR,
+    FUNCTION,
+    PROPERTY_GETTER,
+    PROPERTY_SETTER,
+    TYPE,
+    TYPEALIAS,
+    FILE,
+)
+internal annotation class ExcludeFromSources
+
+/**
+ * Any `Documentable` annotated with this annotation will be exported to HTML by the documentation
+ * processor.
+ *
+ * You can use @exportAsHtmlStart and @exportAsHtmlEnd to specify a range of the doc to
+ * export to HTML.
+ *
+ * **NOTE: DO NOT RENAME!**
+ *
+ * @param theme Whether to include a simple theme in the HTML file. Default is `true`.
+ * @param stripReferences Whether to strip `[references]` from the HTML file. Default is `true`.
+ *  This is useful when you want to include the HTML file in a website, where the references are not
+ *  needed or would break.
+ */
+@Target(
+    CLASS,
+    ANNOTATION_CLASS,
+    PROPERTY,
+    FIELD,
+    LOCAL_VARIABLE,
+    VALUE_PARAMETER,
+    CONSTRUCTOR,
+    FUNCTION,
+    PROPERTY_GETTER,
+    PROPERTY_SETTER,
+    TYPE,
+    TYPEALIAS,
+    FILE,
+)
+internal annotation class ExportAsHtml(val theme: Boolean = true, val stripReferences: Boolean = true)
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/exceptions/CellConversionException.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/exceptions/CellConversionException.kt
new file mode 100644
index 000000000..3c027fb51
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/exceptions/CellConversionException.kt
@@ -0,0 +1,16 @@
+package org.jetbrains.kotlinx.dataframe.exceptions
+
+import org.jetbrains.kotlinx.dataframe.columns.ColumnPath
+import kotlin.reflect.KType
+
+public class CellConversionException(
+    value: Any?,
+    from: KType,
+    to: KType,
+    column: ColumnPath,
+    public val row: Int?,
+    override val cause: Throwable?,
+) : TypeConversionException(value, from, to, column) {
+    override val message: String
+        get() = "${super.message} in column $column, row $row"
+}
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/exceptions/ColumnNotFoundException.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/exceptions/ColumnNotFoundException.kt
new file mode 100644
index 000000000..2098b18b7
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/exceptions/ColumnNotFoundException.kt
@@ -0,0 +1,4 @@
+package org.jetbrains.kotlinx.dataframe.exceptions
+
+public class ColumnNotFoundException(public val columnName: String, public override val message: String) :
+    RuntimeException()
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/exceptions/DuplicateColumnNamesException.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/exceptions/DuplicateColumnNamesException.kt
new file mode 100644
index 000000000..be2db6c9d
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/exceptions/DuplicateColumnNamesException.kt
@@ -0,0 +1,12 @@
+package org.jetbrains.kotlinx.dataframe.exceptions
+
+public class DuplicateColumnNamesException(public val allColumnNames: List<String>) : IllegalArgumentException() {
+
+    public val duplicatedNames: List<String> = allColumnNames
+        .groupBy { it }
+        .filter { it.key != "" && it.value.size > 1 }
+        .map { it.key }
+
+    override val message: String
+        get() = "Duplicate column names: $duplicatedNames\nAll column names: $allColumnNames"
+}
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/exceptions/ExcessiveColumnsException.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/exceptions/ExcessiveColumnsException.kt
new file mode 100644
index 000000000..ae5f6f449
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/exceptions/ExcessiveColumnsException.kt
@@ -0,0 +1,7 @@
+package org.jetbrains.kotlinx.dataframe.exceptions
+
+public class ExcessiveColumnsException(public val columns: List<String>) : RuntimeException() {
+
+    override val message: String
+        get() = "Excess columns in DataFrame: $columns"
+}
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/exceptions/TypeConversionException.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/exceptions/TypeConversionException.kt
new file mode 100644
index 000000000..baf67a06d
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/exceptions/TypeConversionException.kt
@@ -0,0 +1,16 @@
+package org.jetbrains.kotlinx.dataframe.exceptions
+
+import org.jetbrains.kotlinx.dataframe.columns.ColumnPath
+import kotlin.reflect.KType
+
+public open class TypeConversionException(
+    public val value: Any?,
+    public val from: KType,
+    public val to: KType,
+    public val column: ColumnPath?,
+) : RuntimeException() {
+
+    override val message: String
+        get() = "Failed to convert '$value' from $from to $to" +
+            (column?.let { " in column '${it.joinToString()}'" } ?: "")
+}
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/exceptions/TypeConverterNotFoundException.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/exceptions/TypeConverterNotFoundException.kt
new file mode 100644
index 000000000..f4b1b7ab6
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/exceptions/TypeConverterNotFoundException.kt
@@ -0,0 +1,15 @@
+package org.jetbrains.kotlinx.dataframe.exceptions
+
+import org.jetbrains.kotlinx.dataframe.columns.ColumnPath
+import kotlin.reflect.KType
+
+public class TypeConverterNotFoundException(
+    public val from: KType,
+    public val to: KType,
+    public val column: ColumnPath?,
+) : IllegalArgumentException() {
+
+    override val message: String
+        get() = "Type converter from $from to $to is not found" +
+            (column?.let { " for column '${it.joinToString()}'" } ?: "")
+}
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/exceptions/UnequalColumnSizesException.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/exceptions/UnequalColumnSizesException.kt
new file mode 100644
index 000000000..78a3846fb
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/exceptions/UnequalColumnSizesException.kt
@@ -0,0 +1,12 @@
+package org.jetbrains.kotlinx.dataframe.exceptions
+
+public class UnequalColumnSizesException(
+    public val expectedRowsCount: Int,
+    public val columnSizes: List<Pair<String, Int>>,
+) : IllegalArgumentException() {
+
+    override val message: String
+        get() = "Unequal column sizes. Expected rows count: $expectedRowsCount. Actual column sizes:\n${
+            columnSizes.joinToString("\n") { it.first + ": " + it.second }
+        }"
+}
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/Cache.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/Cache.kt
new file mode 100644
index 000000000..cc15393a0
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/Cache.kt
@@ -0,0 +1,9 @@
+package org.jetbrains.kotlinx.dataframe.impl
+
+import kotlin.reflect.KType
+
+private val listTypes = mutableMapOf<KType, KType>()
+
+@PublishedApi
+internal fun getListType(valueType: KType): KType =
+    listTypes.getOrPut(valueType) { List::class.createTypeWithArgument(valueType) }
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/ColumnAccessTracker.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/ColumnAccessTracker.kt
new file mode 100644
index 000000000..b2d79256f
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/ColumnAccessTracker.kt
@@ -0,0 +1,33 @@
+package org.jetbrains.kotlinx.dataframe.impl
+
+import kotlin.concurrent.getOrSet
+
+internal class ColumnAccessTracker {
+
+    var isEnabled = false
+
+    val accessedColumns = mutableSetOf<String>()
+
+    fun <T> track(body: () -> T): List<String> {
+        accessedColumns.clear()
+        isEnabled = true
+        body()
+        isEnabled = false
+        return accessedColumns.toList()
+    }
+
+    fun registerAccess(columnName: String) {
+        if (isEnabled) accessedColumns.add(columnName)
+    }
+
+    companion object {
+
+        fun registerColumnAccess(name: String) = get().registerAccess(name)
+
+        fun get() = columnAccessTracker.getOrSet { ColumnAccessTracker() }
+    }
+}
+
+internal val columnAccessTracker = ThreadLocal<ColumnAccessTracker>()
+
+public fun trackColumnAccess(body: () -> Unit): List<String> = ColumnAccessTracker.get().track(body)
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/ColumnDataCollector.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/ColumnDataCollector.kt
new file mode 100644
index 000000000..2d7b7e7d7
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/ColumnDataCollector.kt
@@ -0,0 +1,86 @@
+package org.jetbrains.kotlinx.dataframe.impl
+
+import org.jetbrains.kotlinx.dataframe.AnyFrame
+import org.jetbrains.kotlinx.dataframe.AnyRow
+import org.jetbrains.kotlinx.dataframe.DataColumn
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.DataRow
+import org.jetbrains.kotlinx.dataframe.api.concat
+import org.jetbrains.kotlinx.dataframe.api.toDataFrame
+import org.jetbrains.kotlinx.dataframe.impl.columns.guessColumnType
+import kotlin.reflect.KClass
+import kotlin.reflect.KType
+import kotlin.reflect.full.isSubclassOf
+import kotlin.reflect.full.withNullability
+import kotlin.reflect.jvm.jvmErasure
+
+internal interface DataCollector<T> {
+
+    public val data: List<T?>
+    public val hasNulls: Boolean
+
+    public fun add(value: T)
+
+    public fun toColumn(name: String): DataColumn<T>
+}
+
+internal abstract class DataCollectorBase<T>(initCapacity: Int) : DataCollector<T> {
+
+    override var hasNulls = false
+
+    override val data = ArrayList<T?>(initCapacity)
+
+    val values: List<T?>
+        get() = data
+
+    override fun add(value: T) {
+        if (value == null) hasNulls = true
+        data.add(value)
+    }
+
+    protected fun createColumn(name: String, type: KType): DataColumn<T> {
+        val classifier = type.classifier as KClass<*>
+        if (classifier.isSubclassOf(DataFrame::class) && !hasNulls) {
+            return DataColumn.createFrameColumn(name, data as List<AnyFrame>) as DataColumn<T>
+        }
+        if (classifier.isSubclassOf(DataRow::class) && !hasNulls) {
+            val mergedDf = (data as List<AnyRow>).map { it.toDataFrame() }.concat()
+            return DataColumn.createColumnGroup(name, mergedDf) as DataColumn<T>
+        }
+        return DataColumn.createValueColumn(name, data, type.withNullability(hasNulls)) as DataColumn<T>
+    }
+}
+
+internal open class ColumnDataCollector(initCapacity: Int = 0, val typeOf: (KClass<*>) -> KType) :
+    DataCollectorBase<Any?>(initCapacity) {
+
+    override fun toColumn(name: String) = guessColumnType(name, values)
+}
+
+internal class TypedColumnDataCollector<T>(initCapacity: Int = 0, val type: KType, val checkTypes: Boolean = true) :
+    DataCollectorBase<T?>(initCapacity) {
+
+    internal val kclass = type.jvmErasure
+
+    override fun add(value: T?) {
+        if (checkTypes && value != null && !value.javaClass.kotlin.isSubclassOf(kclass)) {
+            throw IllegalArgumentException(
+                "Can not add value of class ${value.javaClass.kotlin.qualifiedName} to column of type $type. Value = $value",
+            )
+        }
+        super.add(value)
+    }
+
+    override fun toColumn(name: String) = createColumn(name, type)
+}
+
+internal fun createDataCollector(initCapacity: Int = 0) =
+    createDataCollector(initCapacity) {
+        it.createStarProjectedType(false)
+    }
+
+internal fun createDataCollector(initCapacity: Int = 0, typeOf: (KClass<*>) -> KType) =
+    ColumnDataCollector(initCapacity, typeOf)
+
+internal fun <T> createDataCollector(initCapacity: Int = 0, type: KType) =
+    TypedColumnDataCollector<T>(initCapacity, type)
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/ColumnNameGenerator.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/ColumnNameGenerator.kt
new file mode 100644
index 000000000..c6549d26f
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/ColumnNameGenerator.kt
@@ -0,0 +1,37 @@
+package org.jetbrains.kotlinx.dataframe.impl
+
+import org.jetbrains.kotlinx.dataframe.AnyFrame
+
+internal class ColumnNameGenerator(columnNames: List<String> = emptyList()) {
+
+    private val usedNames = columnNames.toMutableSet()
+
+    private val colNames = columnNames.toMutableList()
+
+    fun addUnique(preferredName: String): String {
+        var name = preferredName
+        var k = 1
+        while (usedNames.contains(name)) {
+            name = "${preferredName}${k++}"
+        }
+        usedNames.add(name)
+        colNames.add(name)
+        return name
+    }
+
+    fun addIfAbsent(name: String) {
+        if (!usedNames.contains(name)) {
+            usedNames.add(name)
+            colNames.add(name)
+        }
+    }
+
+    val names: List<String>
+        get() = colNames
+
+    fun contains(name: String) = usedNames.contains(name)
+}
+
+internal fun AnyFrame.nameGenerator() = ColumnNameGenerator(columnNames())
+
+internal fun nameGenerator(vararg usedNames: String) = ColumnNameGenerator(usedNames.asList())
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/DataFrameImpl.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/DataFrameImpl.kt
new file mode 100644
index 000000000..c80d8ebb9
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/DataFrameImpl.kt
@@ -0,0 +1,170 @@
+package org.jetbrains.kotlinx.dataframe.impl
+
+import org.jetbrains.kotlinx.dataframe.AnyCol
+import org.jetbrains.kotlinx.dataframe.AnyFrame
+import org.jetbrains.kotlinx.dataframe.ColumnSelector
+import org.jetbrains.kotlinx.dataframe.ColumnsSelector
+import org.jetbrains.kotlinx.dataframe.DataColumn
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.DataRow
+import org.jetbrains.kotlinx.dataframe.aggregation.AggregateGroupedBody
+import org.jetbrains.kotlinx.dataframe.api.asColumnGroup
+import org.jetbrains.kotlinx.dataframe.api.asDataColumn
+import org.jetbrains.kotlinx.dataframe.api.cast
+import org.jetbrains.kotlinx.dataframe.api.getColumn
+import org.jetbrains.kotlinx.dataframe.api.indices
+import org.jetbrains.kotlinx.dataframe.api.name
+import org.jetbrains.kotlinx.dataframe.api.toColumnAccessor
+import org.jetbrains.kotlinx.dataframe.columns.ColumnPath
+import org.jetbrains.kotlinx.dataframe.columns.ColumnReference
+import org.jetbrains.kotlinx.dataframe.columns.UnresolvedColumnsPolicy
+import org.jetbrains.kotlinx.dataframe.columns.size
+import org.jetbrains.kotlinx.dataframe.exceptions.DuplicateColumnNamesException
+import org.jetbrains.kotlinx.dataframe.exceptions.UnequalColumnSizesException
+import org.jetbrains.kotlinx.dataframe.impl.aggregation.AggregatableInternal
+import org.jetbrains.kotlinx.dataframe.impl.aggregation.GroupByReceiverImpl
+import org.jetbrains.kotlinx.dataframe.impl.columns.resolveSingle
+import org.jetbrains.kotlinx.dataframe.io.renderToString
+import kotlin.reflect.KProperty
+
+internal const val UNNAMED_COLUMN_PREFIX = "untitled"
+
+internal open class DataFrameImpl<T>(cols: List<AnyCol>, val nrow: Int) :
+    DataFrame<T>,
+    AggregatableInternal<T> {
+
+    private val columnsMap: Map<String, Int>
+
+    protected val columns: List<AnyCol>
+
+    init {
+        columnsMap = mutableMapOf()
+
+        // check that column sizes are equal
+        if (cols.any { it.size != nrow }) {
+            throw UnequalColumnSizesException(nrow, cols.map { it.name to it.size })
+        }
+
+        // check that column names are unique
+        var hasUnnamedColumns = false
+        cols.forEachIndexed { i, col ->
+            val name = col.name
+            if (name.isEmpty()) {
+                hasUnnamedColumns = true
+            } else {
+                if (columnsMap.containsKey(name)) {
+                    throw DuplicateColumnNamesException(cols.map { it.name })
+                }
+                columnsMap[name] = i
+            }
+        }
+
+        // generate unique names for unnamed columns
+        if (hasUnnamedColumns) {
+            val nameGenerator = ColumnNameGenerator(cols.map { it.name })
+            columns = cols.mapIndexed { i, col ->
+                val name = col.name
+                if (name.isEmpty()) {
+                    val uniqueName = nameGenerator.addUnique(UNNAMED_COLUMN_PREFIX)
+                    val renamed = col.rename(uniqueName)
+                    columnsMap[uniqueName] = i
+                    renamed
+                } else {
+                    col
+                }
+            }
+        } else {
+            columns = cols
+        }
+    }
+
+    override fun rowsCount() = nrow
+
+    override fun getColumnIndex(name: String) = columnsMap[name] ?: -1
+
+    override fun equals(other: Any?): Boolean {
+        val df = other as? AnyFrame ?: return false
+        return columns == df.columns()
+    }
+
+    override fun hashCode() = columns.hashCode()
+
+    override fun toString() = renderToString()
+
+    override fun columns() = columns
+
+    override fun columnNames() = columns.map { it.name() }
+
+    override fun columnTypes() = columns.map { it.type() }
+
+    override fun columnsCount(): Int = columns.size
+
+    override operator fun get(index: Int): DataRow<T> {
+        if (index < 0 || index >= nrow) {
+            throw IndexOutOfBoundsException("index: $index, rowsCount: $nrow")
+        }
+        return DataRowImpl(index, this)
+    }
+
+    override fun remainingColumnsSelector(): ColumnsSelector<*, *> = { all() }
+
+    override fun <R> aggregate(body: AggregateGroupedBody<T, R>): DataRow<T> {
+        val receiver = GroupByReceiverImpl(this, false)
+        body(receiver, receiver)
+        val row = receiver.compute() ?: DataFrame.empty(1)[0]
+        return row.cast()
+    }
+
+    override fun getColumnOrNull(name: String): AnyCol? =
+        getColumnIndex(name).let { if (it != -1) getColumn(it) else null }
+
+    override fun getColumnOrNull(index: Int) = if (index >= 0 && index < columns.size) columns[index] else null
+
+    override fun <R> getColumnOrNull(column: ColumnSelector<T, R>): DataColumn<R>? =
+        getColumnsImpl(
+            unresolvedColumnsPolicy = UnresolvedColumnsPolicy.Skip,
+            selector = column,
+        ).singleOrNull()
+
+    override fun <R> getColumnOrNull(column: ColumnReference<R>): DataColumn<R>? =
+        column.resolveSingle(this, UnresolvedColumnsPolicy.Skip)?.data
+
+    override fun <R> getColumnOrNull(column: KProperty<R>): DataColumn<R>? = getColumnOrNull(column.toColumnAccessor())
+
+    override fun getColumnOrNull(path: ColumnPath): AnyCol? =
+        when (path.size) {
+            0 -> asColumnGroup().asDataColumn()
+
+            1 -> getColumnOrNull(path[0])
+
+            else ->
+                path.dropLast(1)
+                    .fold(this as AnyFrame?) { df, name -> df?.getColumnOrNull(name) as? AnyFrame? }
+                    ?.getColumnOrNull(path.last())
+        }
+
+    override fun containsColumn(name: String): Boolean = columnsMap.containsKey(name)
+
+    override fun containsColumn(path: ColumnPath): Boolean = getColumnOrNull(path) != null
+}
+
+internal fun <T, C> DataFrame<T>.valuesImpl(byRow: Boolean, columns: ColumnsSelector<T, C>): Sequence<C> {
+    val cols = get(columns)
+    return if (byRow) {
+        sequence {
+            indices().forEach { row ->
+                cols.forEach {
+                    yield(it[row])
+                }
+            }
+        }
+    } else {
+        sequence {
+            cols.forEach { col ->
+                col.values().forEach {
+                    yield(it)
+                }
+            }
+        }
+    }
+}
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/DataFrameReceiver.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/DataFrameReceiver.kt
new file mode 100644
index 000000000..f85095bd8
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/DataFrameReceiver.kt
@@ -0,0 +1,87 @@
+package org.jetbrains.kotlinx.dataframe.impl
+
+import org.jetbrains.kotlinx.dataframe.ColumnSelector
+import org.jetbrains.kotlinx.dataframe.DataColumn
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.DataRow
+import org.jetbrains.kotlinx.dataframe.api.asDataColumn
+import org.jetbrains.kotlinx.dataframe.api.cast
+import org.jetbrains.kotlinx.dataframe.api.isColumnGroup
+import org.jetbrains.kotlinx.dataframe.api.pathOf
+import org.jetbrains.kotlinx.dataframe.columns.ColumnGroup
+import org.jetbrains.kotlinx.dataframe.columns.ColumnPath
+import org.jetbrains.kotlinx.dataframe.columns.ColumnReference
+import org.jetbrains.kotlinx.dataframe.columns.ColumnResolutionContext
+import org.jetbrains.kotlinx.dataframe.columns.ColumnWithPath
+import org.jetbrains.kotlinx.dataframe.columns.SingleColumn
+import org.jetbrains.kotlinx.dataframe.columns.UnresolvedColumnsPolicy
+import org.jetbrains.kotlinx.dataframe.impl.columns.ColumnGroupWithParent
+import org.jetbrains.kotlinx.dataframe.impl.columns.ColumnGroupWithPathImpl
+import org.jetbrains.kotlinx.dataframe.impl.columns.addPath
+import org.jetbrains.kotlinx.dataframe.impl.columns.missing.MissingColumnGroup
+import org.jetbrains.kotlinx.dataframe.impl.columns.missing.MissingDataColumn
+import org.jetbrains.kotlinx.dataframe.nrow
+
+private fun <T> DataFrame<T>.unbox(): DataFrame<T> =
+    when (this) {
+        is ColumnGroupWithParent -> source.unbox()
+        is ColumnGroupWithPathImpl -> column.unbox()
+        else -> this
+    }
+
+internal abstract class DataFrameReceiverBase<T>(protected val df: DataFrame<T>) :
+    DataFrameImpl<T>(df.columns(), df.nrow)
+
+internal open class DataFrameReceiver<T>(
+    source: DataFrame<T>,
+    private val unresolvedColumnsPolicy: UnresolvedColumnsPolicy,
+) : DataFrameReceiverBase<T>(source.unbox()),
+    SingleColumn<DataRow<T>> {
+
+    private fun <R> DataColumn<R>?.check(path: ColumnPath): DataColumn<R> =
+        when (this) {
+            null -> when (unresolvedColumnsPolicy) {
+                UnresolvedColumnsPolicy.Create, UnresolvedColumnsPolicy.Skip ->
+                    MissingColumnGroup<Any>(
+                        path = path,
+                        host = this@DataFrameReceiver,
+                    ).asDataColumn().cast()
+
+                UnresolvedColumnsPolicy.Fail -> error(
+                    "Column '${path.joinToString()}' not found among ${df.columnNames()}.",
+                )
+            }
+
+            is MissingDataColumn -> this
+
+            is ColumnGroup<*> -> ColumnGroupWithParent(null, this).asDataColumn().cast()
+
+            else -> this
+        }
+
+    override fun getColumnOrNull(name: String) = df.getColumnOrNull(name).check(pathOf(name))
+
+    override fun getColumnOrNull(index: Int) = df.getColumnOrNull(index).check(pathOf(""))
+
+    override fun <R> getColumnOrNull(column: ColumnReference<R>): DataColumn<R>? {
+        val context = ColumnResolutionContext(this, unresolvedColumnsPolicy)
+        return column.resolveSingle(context).check(column.path())
+    }
+
+    override fun getColumnOrNull(path: ColumnPath) = super.getColumnOrNull(path).check(path)
+
+    override fun <R> getColumnOrNull(column: ColumnSelector<T, R>) =
+        getColumnsImpl(unresolvedColumnsPolicy, column).singleOrNull()
+
+    override fun resolveSingle(context: ColumnResolutionContext): ColumnWithPath<DataRow<T>>? =
+        DataColumn.createColumnGroup("", df).addPath(emptyPath())
+
+    override fun columns() =
+        df.columns().map {
+            if (it.isColumnGroup()) ColumnGroupWithParent(null, it) else it
+        }
+
+    override fun columnNames() = df.columnNames()
+
+    override fun columnTypes() = df.columnTypes()
+}
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/DataFrameSize.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/DataFrameSize.kt
new file mode 100644
index 000000000..a51cc421e
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/DataFrameSize.kt
@@ -0,0 +1,5 @@
+package org.jetbrains.kotlinx.dataframe.impl
+
+public data class DataFrameSize(val ncol: Int, val nrow: Int) {
+    override fun toString(): String = "$nrow x $ncol"
+}
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/DataRowImpl.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/DataRowImpl.kt
new file mode 100644
index 000000000..e81558550
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/DataRowImpl.kt
@@ -0,0 +1,70 @@
+package org.jetbrains.kotlinx.dataframe.impl
+
+import org.jetbrains.kotlinx.dataframe.AnyRow
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.DataRow
+import org.jetbrains.kotlinx.dataframe.aggregation.NamedValue
+import org.jetbrains.kotlinx.dataframe.api.getColumn
+import org.jetbrains.kotlinx.dataframe.columns.ColumnReference
+import org.jetbrains.kotlinx.dataframe.columns.shortPath
+import org.jetbrains.kotlinx.dataframe.index
+import org.jetbrains.kotlinx.dataframe.io.renderToString
+
+internal open class DataRowImpl<T>(private val index: Int, private val df: DataFrame<T>) : DataRow<T> {
+
+    override fun df() = df
+
+    override operator fun get(name: String): Any? {
+        ColumnAccessTracker.registerColumnAccess(name)
+        return df[name][index]
+    }
+
+    override operator fun <R> get(column: ColumnReference<R>): R {
+        ColumnAccessTracker.registerColumnAccess(column.name())
+        return column.getValue(this)
+    }
+
+    override fun <R> getValueOrNull(column: ColumnReference<R>): R? {
+        ColumnAccessTracker.registerColumnAccess(column.name())
+        return column.getValueOrNull(this)
+    }
+
+    override fun index() = index
+
+    private val values by lazy { df.columns().map { it[index] } }
+
+    override fun values() = values
+
+    override fun get(columnIndex: Int): Any? {
+        val column = df.getColumn(columnIndex)
+        ColumnAccessTracker.registerColumnAccess(column.name())
+        return column[index]
+    }
+
+    override fun toString() = renderToString()
+
+    override fun equals(other: Any?): Boolean {
+        val o = other as? DataRowImpl<*> ?: return false
+        return values.equals(o.values)
+    }
+
+    override fun hashCode() = values.hashCode()
+
+    override fun getOrNull(name: String): Any? {
+        ColumnAccessTracker.registerColumnAccess(name)
+        return df.getColumnOrNull(name)?.get(index)
+    }
+}
+
+internal val <T> DataRow<T>.owner: DataFrame<T> get() = df()
+
+internal fun AnyRow.namedValues(): Sequence<NamedValue> =
+    owner.columns().asSequence().map {
+        NamedValue.create(
+            path = it.shortPath(),
+            value = it[index],
+            type = it.type(),
+            defaultValue = it.defaultValue(),
+            guessType = false,
+        )
+    }
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/ExceptionUtils.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/ExceptionUtils.kt
new file mode 100644
index 000000000..6da0acdba
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/ExceptionUtils.kt
@@ -0,0 +1,7 @@
+package org.jetbrains.kotlinx.dataframe.impl
+
+internal fun <T> T?.throwIfNull(message: String): T = this ?: throw NoSuchElementException(message)
+
+@PublishedApi
+internal fun <T> T?.suggestIfNull(operation: String): T =
+    throwIfNull("No elements for `$operation` operation. Use `${operation}OrNull` instead.")
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/GroupByImpl.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/GroupByImpl.kt
new file mode 100644
index 000000000..4c3cd3ee3
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/GroupByImpl.kt
@@ -0,0 +1,115 @@
+package org.jetbrains.kotlinx.dataframe.impl
+
+import org.jetbrains.kotlinx.dataframe.ColumnSelector
+import org.jetbrains.kotlinx.dataframe.ColumnsSelector
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.Selector
+import org.jetbrains.kotlinx.dataframe.aggregation.AggregateGroupedBody
+import org.jetbrains.kotlinx.dataframe.aggregation.NamedValue
+import org.jetbrains.kotlinx.dataframe.api.GroupBy
+import org.jetbrains.kotlinx.dataframe.api.GroupedRowFilter
+import org.jetbrains.kotlinx.dataframe.api.asGroupBy
+import org.jetbrains.kotlinx.dataframe.api.concat
+import org.jetbrains.kotlinx.dataframe.api.convert
+import org.jetbrains.kotlinx.dataframe.api.getColumn
+import org.jetbrains.kotlinx.dataframe.api.getColumnsWithPaths
+import org.jetbrains.kotlinx.dataframe.api.into
+import org.jetbrains.kotlinx.dataframe.api.isColumnGroup
+import org.jetbrains.kotlinx.dataframe.api.minus
+import org.jetbrains.kotlinx.dataframe.api.pathOf
+import org.jetbrains.kotlinx.dataframe.api.rename
+import org.jetbrains.kotlinx.dataframe.columns.FrameColumn
+import org.jetbrains.kotlinx.dataframe.impl.aggregation.AggregatableInternal
+import org.jetbrains.kotlinx.dataframe.impl.aggregation.GroupByReceiverImpl
+import org.jetbrains.kotlinx.dataframe.impl.api.AggregatedPivot
+import org.jetbrains.kotlinx.dataframe.impl.api.ColumnToInsert
+import org.jetbrains.kotlinx.dataframe.impl.api.GroupedDataRowImpl
+import org.jetbrains.kotlinx.dataframe.impl.api.insertImpl
+import org.jetbrains.kotlinx.dataframe.impl.api.removeImpl
+import org.jetbrains.kotlinx.dataframe.impl.columns.toColumnSet
+import org.jetbrains.kotlinx.dataframe.ncol
+import org.jetbrains.kotlinx.dataframe.nrow
+import org.jetbrains.kotlinx.dataframe.values
+
+/**
+ * @property df DataFrame containing [groups] column and key columns. Represents GroupBy.
+ */
+internal class GroupByImpl<T, G>(
+    val df: DataFrame<T>,
+    override val groups: FrameColumn<G>,
+    internal val keyColumnsInGroups: ColumnsSelector<G, *>,
+) : GroupBy<T, G>,
+    AggregatableInternal<G> {
+
+    override val keys by lazy { df - groups }
+
+    override fun <R> updateGroups(transform: Selector<DataFrame<G>, DataFrame<R>>) =
+        df.convert(groups) { transform(it, it) }.asGroupBy(groups.name()) as GroupBy<T, R>
+
+    override fun toString() = df.toString()
+
+    override fun remainingColumnsSelector(): ColumnsSelector<*, *> =
+        keyColumnsInGroups.toColumnSet().let { groupCols -> { all().except(groupCols) } }
+
+    override fun filter(predicate: GroupedRowFilter<T, G>): GroupBy<T, G> {
+        val indices = (0 until df.nrow).filter {
+            val row = GroupedDataRowImpl(df.get(it), groups)
+            predicate(row, row)
+        }
+        return df[indices].asGroupBy(groups)
+    }
+
+    override fun toDataFrame(groupedColumnName: String?): DataFrame<T> =
+        if (groupedColumnName == null || groupedColumnName == groups.name()) {
+            df
+        } else {
+            df.rename(groups).into(groupedColumnName)
+        }
+}
+
+internal fun <T, G, R> aggregateGroupBy(
+    df: DataFrame<T>,
+    selector: ColumnSelector<T, DataFrame<G>?>,
+    removeColumns: Boolean,
+    body: AggregateGroupedBody<G, R>,
+): DataFrame<T> {
+    val defaultAggregateName = "aggregated"
+
+    val column = df.getColumn(selector)
+
+    val removed = df.removeImpl(columns = selector)
+
+    val hasKeyColumns = removed.df.ncol > 0
+
+    val groupedFrame = column.values.map {
+        if (it == null) {
+            null
+        } else {
+            val builder = GroupByReceiverImpl(it, hasKeyColumns)
+            val result = body(builder, builder)
+            if (result != Unit && result !is NamedValue && result !is AggregatedPivot<*>) {
+                builder.yield(
+                    NamedValue.create(
+                        path = pathOf(defaultAggregateName),
+                        value = result,
+                        type = null,
+                        defaultValue = null,
+                        guessType = true,
+                    ),
+                )
+            }
+            builder.compute()
+        }
+    }.concat()
+
+    val removedNode = removed.removedColumns.single()
+    val insertPath = removedNode.pathFromRoot().dropLast(1)
+
+    if (!removeColumns) removedNode.data.wasRemoved = false
+
+    val columnsToInsert = groupedFrame.getColumnsWithPaths { colsAtAnyDepth { !it.isColumnGroup() } }.map {
+        ColumnToInsert(insertPath + it.path, it, removedNode)
+    }
+    val src = if (removeColumns) removed.df else df
+    return src.insertImpl(columnsToInsert)
+}
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/MathUtils.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/MathUtils.kt
new file mode 100644
index 000000000..a2d0bef65
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/MathUtils.kt
@@ -0,0 +1,30 @@
+package org.jetbrains.kotlinx.dataframe.impl
+
+import org.jetbrains.kotlinx.dataframe.DataColumn
+import org.jetbrains.kotlinx.dataframe.io.DEFAULT_PRECISION
+import org.jetbrains.kotlinx.dataframe.typeClass
+import java.math.BigDecimal
+
+internal fun <T : Number> DataColumn<T?>.scale(): Int {
+    if (size() == 0) return 0
+    return when (typeClass) {
+        Double::class -> values().maxOf { (it as? Double)?.scale() ?: 1 }
+        Float::class -> values().maxOf { (it as? Float)?.scale() ?: 1 }
+        BigDecimal::class -> values().maxOf { (it as? BigDecimal)?.scale() ?: 1 }
+        Number::class -> values().maxOf { (it as? Number)?.scale() ?: 0 }
+        else -> 0
+    }.coerceAtMost(DEFAULT_PRECISION)
+}
+
+internal fun Double.scale() = if (isFinite()) toBigDecimal().scale() else 0
+
+internal fun Float.scale() = if (isFinite()) toBigDecimal().scale() else 0
+
+internal fun Number.scale(): Int =
+    when (this) {
+        is Double -> scale()
+        is Float -> scale()
+        is Int, is Long -> 0
+        is BigDecimal -> scale()
+        else -> 0
+    }
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/Rendering.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/Rendering.kt
new file mode 100644
index 000000000..222a6da24
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/Rendering.kt
@@ -0,0 +1,124 @@
+package org.jetbrains.kotlinx.dataframe.impl
+
+import org.jetbrains.kotlinx.dataframe.AnyCol
+import org.jetbrains.kotlinx.dataframe.AnyFrame
+import org.jetbrains.kotlinx.dataframe.api.asColumnGroup
+import org.jetbrains.kotlinx.dataframe.api.asDataFrame
+import org.jetbrains.kotlinx.dataframe.columns.ColumnKind
+import org.jetbrains.kotlinx.dataframe.impl.columns.asAnyFrameColumn
+import org.jetbrains.kotlinx.dataframe.io.escapeHTML
+import org.jetbrains.kotlinx.dataframe.jupyter.RenderedContent
+import org.jetbrains.kotlinx.dataframe.schema.ColumnSchema
+import org.jetbrains.kotlinx.dataframe.schema.DataFrameSchema
+import org.jetbrains.kotlinx.dataframe.size
+import org.jetbrains.kotlinx.dataframe.type
+import java.net.URL
+import java.time.LocalDateTime
+import java.time.LocalTime
+import kotlin.reflect.KType
+import kotlin.reflect.full.isSubtypeOf
+import kotlin.reflect.jvm.jvmErasure
+import kotlin.reflect.typeOf
+
+internal fun String.truncate(limit: Int): RenderedContent =
+    if (limit in 1 until length) {
+        if (limit < 4) {
+            RenderedContent.truncatedText("...", this)
+        } else {
+            RenderedContent.truncatedText(substring(0, (limit - 3).coerceAtLeast(1)) + "...", this)
+        }
+    } else {
+        RenderedContent.text(this)
+    }
+
+internal fun renderSchema(df: AnyFrame): String = df.columns().joinToString { "${it.name()}:${renderType(it)}" }
+
+internal fun renderSchema(schema: DataFrameSchema): String =
+    schema.columns.map { "${it.key}:${renderType(it.value)}" }.joinToString()
+
+internal fun renderType(column: ColumnSchema) =
+    when (column) {
+        is ColumnSchema.Value -> {
+            renderType(column.type)
+        }
+
+        is ColumnSchema.Frame -> {
+            "[${renderSchema(column.schema)}]"
+        }
+
+        is ColumnSchema.Group -> {
+            "{${renderSchema(column.schema)}}"
+        }
+
+        else -> throw NotImplementedError()
+    }
+
+internal fun renderType(type: KType?): String {
+    return when (type?.classifier) {
+        null -> "*"
+
+        Nothing::class -> "Nothing" + if (type.isMarkedNullable) "?" else ""
+
+        else -> {
+            val fullName = type.jvmErasure.qualifiedName ?: return type.toString()
+            val name = when {
+                // catching cases like `typeOf<Array<Int>>().jvmErasure.qualifiedName == "IntArray"`
+                // https://github.com/Kotlin/dataframe/issues/678
+                type.isSubtypeOf(typeOf<Array<*>>()) ->
+                    "Array"
+
+                type.classifier == URL::class ->
+                    fullName.removePrefix("java.net.")
+
+                type.classifier in listOf(LocalDateTime::class, LocalTime::class) ->
+                    fullName.removePrefix("java.time.")
+
+                fullName.startsWith("kotlin.collections.") ->
+                    fullName.removePrefix("kotlin.collections.")
+
+                fullName.startsWith("kotlin.") ->
+                    fullName.removePrefix("kotlin.")
+
+                fullName.startsWith("org.jetbrains.kotlinx.dataframe.") ->
+                    fullName.removePrefix("org.jetbrains.kotlinx.dataframe.")
+
+                else -> fullName
+            }
+
+            buildString {
+                append(name)
+                if (type.arguments.isNotEmpty()) {
+                    val arguments = type.arguments.joinToString {
+                        renderType(it.type)
+                    }
+                    append("<$arguments>")
+                }
+                if (type.isMarkedNullable) {
+                    append("?")
+                }
+            }
+        }
+    }
+}
+
+internal fun renderType(column: AnyCol) =
+    when (column.kind()) {
+        ColumnKind.Value -> renderType(column.type)
+
+        ColumnKind.Frame -> {
+            val table = column.asAnyFrameColumn()
+            "[${renderSchema(table.schema.value)}]"
+        }
+
+        ColumnKind.Group -> {
+            val group = column.asColumnGroup()
+            "{${renderSchema(group)}}"
+        }
+    }
+
+internal fun AnyCol.renderShort() =
+    when (kind()) {
+        ColumnKind.Value -> "ValueColumn<${renderType(type)}>: $size entries".escapeHTML()
+        ColumnKind.Frame -> "FrameColumn: $size entries"
+        ColumnKind.Group -> "ColumnGroup ${asColumnGroup().asDataFrame().size}}"
+    }
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/Utils.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/Utils.kt
new file mode 100644
index 000000000..21f8bb639
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/Utils.kt
@@ -0,0 +1,418 @@
+package org.jetbrains.kotlinx.dataframe.impl
+
+import org.jetbrains.kotlinx.dataframe.ColumnsSelector
+import org.jetbrains.kotlinx.dataframe.DataColumn
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.Predicate
+import org.jetbrains.kotlinx.dataframe.annotations.ColumnName
+import org.jetbrains.kotlinx.dataframe.api.cast
+import org.jetbrains.kotlinx.dataframe.columns.ColumnPath
+import org.jetbrains.kotlinx.dataframe.columns.ColumnWithPath
+import org.jetbrains.kotlinx.dataframe.columns.UnresolvedColumnsPolicy
+import org.jetbrains.kotlinx.dataframe.impl.columns.resolve
+import org.jetbrains.kotlinx.dataframe.impl.columns.toColumnSet
+import org.jetbrains.kotlinx.dataframe.nrow
+import java.math.BigDecimal
+import java.math.BigInteger
+import kotlin.reflect.KCallable
+import kotlin.reflect.KClass
+import kotlin.reflect.KFunction
+import kotlin.reflect.KProperty
+import kotlin.reflect.KType
+import kotlin.reflect.KTypeProjection
+import kotlin.reflect.KVariance
+import kotlin.reflect.full.createType
+import kotlin.reflect.full.findAnnotation
+import kotlin.reflect.full.isSubtypeOf
+import kotlin.reflect.full.starProjectedType
+import kotlin.reflect.full.valueParameters
+import kotlin.reflect.full.withNullability
+import kotlin.reflect.jvm.jvmErasure
+import kotlin.reflect.typeOf
+
+internal infix fun <T> (Predicate<T>?).and(other: Predicate<T>): Predicate<T> =
+    if (this == null) other else { it: T -> this(it) && other(it) }
+
+internal fun <T> T.toIterable(getNext: (T) -> T?) =
+    Iterable<T> {
+        object : Iterator<T> {
+
+            var current: T? = null
+            var beforeStart = true
+            var next: T? = null
+
+            override fun hasNext(): Boolean {
+                if (beforeStart) return true
+                if (next == null) next = getNext(current!!)
+                return next != null
+            }
+
+            override fun next(): T {
+                if (beforeStart) {
+                    current = this@toIterable
+                    beforeStart = false
+                    return current!!
+                }
+                current = next ?: getNext(current!!)
+                next = null
+                return current!!
+            }
+        }
+    }
+
+internal fun <T> List<T>.removeAt(index: Int) = subList(0, index) + subList(index + 1, size)
+
+internal inline fun <reified T : Any> Int.cast() = convert(this, T::class)
+
+internal fun <T : Any> convert(src: Int, tartypeOf: KClass<T>): T =
+    when (tartypeOf) {
+        Double::class -> src.toDouble() as T
+        Long::class -> src.toLong() as T
+        Float::class -> src.toFloat() as T
+        BigDecimal::class -> src.toBigDecimal() as T
+        else -> throw NotImplementedError("Casting int to $tartypeOf is not supported")
+    }
+
+internal fun BooleanArray.getTrueIndices(): List<Int> {
+    val res = ArrayList<Int>(size)
+    for (i in indices) {
+        if (this[i]) res.add(i)
+    }
+    return res
+}
+
+internal fun List<Boolean>.getTrueIndices(): List<Int> {
+    val res = ArrayList<Int>(size)
+    for (i in indices) {
+        if (this[i]) res.add(i)
+    }
+    return res
+}
+
+internal fun <T> Iterable<T>.equalsByElement(other: Iterable<T>): Boolean {
+    val iterator1 = iterator()
+    val iterator2 = other.iterator()
+    while (iterator1.hasNext() && iterator2.hasNext()) {
+        if (iterator1.next() != iterator2.next()) return false
+    }
+    if (iterator1.hasNext() || iterator2.hasNext()) return false
+    return true
+}
+
+internal fun <T> Iterable<T>.rollingHash(): Int {
+    val i = iterator()
+    var hash = 0
+    while (i.hasNext()) {
+        hash = 31 * hash + (i.next()?.hashCode() ?: 5)
+    }
+    return hash
+}
+
+public fun <T> Iterable<T>.asList(): List<T> =
+    when (this) {
+        is List<T> -> this
+        else -> this.toList()
+    }
+
+@PublishedApi
+internal fun <T> Iterable<T>.anyNull(): Boolean = any { it == null }
+
+@PublishedApi
+internal fun emptyPath(): ColumnPath = ColumnPath(emptyList())
+
+@PublishedApi
+internal fun <T : Number> KClass<T>.zeroOrNull(): T? =
+    when (this) {
+        Int::class -> 0 as T
+        Byte::class -> 0.toByte() as T
+        Short::class -> 0.toShort() as T
+        Long::class -> 0.toLong() as T
+        Double::class -> 0.toDouble() as T
+        Float::class -> 0.toFloat() as T
+        BigDecimal::class -> BigDecimal.ZERO as T
+        BigInteger::class -> BigInteger.ZERO as T
+        Number::class -> 0 as? T
+        else -> null
+    }
+
+@PublishedApi
+internal fun <T : Number> KClass<T>.zero(): T =
+    zeroOrNull() ?: throw NotImplementedError("Zero value for $this is not supported")
+
+internal fun <T> catchSilent(body: () -> T): T? =
+    try {
+        body()
+    } catch (_: Throwable) {
+        null
+    }
+
+internal fun Iterable<KClass<*>>.commonType(nullable: Boolean, upperBound: KType? = null) =
+    commonParents(this).createType(nullable, upperBound)
+
+/**
+ * Returns the common supertype of the given types.
+ *
+ * @param useStar if true, `*` will be used to fill in generic type parameters instead of `Any?`
+ * (for invariant/out variance) or `Nothing` (for in variance)
+ *
+ * @see Iterable.commonTypeListifyValues
+ */
+internal fun Iterable<KType?>.commonType(useStar: Boolean = true): KType {
+    val distinct = distinct()
+    val nullable = distinct.any { it?.isMarkedNullable ?: true }
+    return when {
+        distinct.isEmpty() || distinct.contains(null) -> typeOf<Any>().withNullability(nullable)
+
+        distinct.size == 1 -> distinct.single()!!
+
+        else -> {
+            // common parent class of all KTypes
+            val kClass = commonParent(distinct.map { it!!.jvmErasure })
+                ?: return typeOf<Any>().withNullability(nullable)
+
+            // all KTypes projected to the common parent class with filled-in generic type parameters (no <T>, but <UpperBound>)
+            val projections = distinct
+                .map { it!!.projectUpTo(kClass).replaceGenericTypeParametersWithUpperbound() }
+            require(projections.all { it.jvmErasure == kClass })
+
+            // make new type arguments for the common parent class
+            val arguments = List(kClass.typeParameters.size) { i ->
+                val typeParameter = kClass.typeParameters[i]
+                val projectionTypes = projections
+                    .map { it.arguments[i].type }
+                    .filterNot { it in distinct } // avoid infinite recursion
+
+                when {
+                    projectionTypes.isEmpty() && typeParameter.variance == KVariance.IN -> {
+                        if (useStar) {
+                            KTypeProjection.STAR
+                        } else {
+                            KTypeProjection.invariant(nothingType(false))
+                        }
+                    }
+
+                    else -> {
+                        val commonType = projectionTypes.commonType(useStar)
+                        if (commonType == typeOf<Any?>() && useStar) {
+                            KTypeProjection.STAR
+                        } else {
+                            KTypeProjection(typeParameter.variance, commonType)
+                        }
+                    }
+                }
+            }
+            kClass.createType(arguments, nullable)
+        }
+    }
+}
+
+internal fun <T, C> DataFrame<T>.getColumnsImpl(
+    unresolvedColumnsPolicy: UnresolvedColumnsPolicy,
+    selector: ColumnsSelector<T, C>,
+): List<DataColumn<C>> = getColumnsWithPaths(unresolvedColumnsPolicy, selector).map { it.data }
+
+internal fun <T, C> DataFrame<T>.getColumnsWithPaths(
+    unresolvedColumnsPolicy: UnresolvedColumnsPolicy,
+    selector: ColumnsSelector<T, C>,
+): List<ColumnWithPath<C>> = selector.toColumnSet().resolve(this, unresolvedColumnsPolicy)
+
+internal fun <T, C> DataFrame<T>.getColumnPaths(
+    unresolvedColumnsPolicy: UnresolvedColumnsPolicy,
+    selector: ColumnsSelector<T, C>,
+): List<ColumnPath> = getColumnsWithPaths(unresolvedColumnsPolicy, selector).map { it.path }
+
+internal fun <C : Comparable<C>> Sequence<C?>.indexOfMin(): Int {
+    val iterator = iterator()
+    if (!iterator.hasNext()) return -1
+    var value = iterator.next()
+    var index = 0
+    while (value == null) {
+        if (!iterator.hasNext()) return -1
+        value = iterator.next()
+        index++
+    }
+    var min: C = value
+    var minIndex = index
+    if (!iterator.hasNext()) return minIndex
+    do {
+        val v = iterator.next()
+        index++
+        if (v != null && min > v) {
+            min = v
+            minIndex = index
+        }
+    } while (iterator.hasNext())
+    return minIndex
+}
+
+internal fun <C : Comparable<C>> Sequence<C?>.indexOfMax(): Int {
+    val iterator = iterator()
+    if (!iterator.hasNext()) return -1
+    var value = iterator.next()
+    var index = 0
+    while (value == null) {
+        if (!iterator.hasNext()) return -1
+        value = iterator.next()
+        index++
+    }
+    var max: C = value
+    var maxIndex = index
+    if (!iterator.hasNext()) return maxIndex
+    do {
+        val v = iterator.next()
+        index++
+        if (v != null && max < v) {
+            max = v
+            maxIndex = index
+        }
+    } while (iterator.hasNext())
+    return maxIndex
+}
+
+internal fun KClass<*>.createStarProjectedType(nullable: Boolean): KType =
+    if (this == Nothing::class) {
+        nothingType(nullable) // would be Void otherwise
+    } else {
+        this.starProjectedType.let { if (nullable) it.withNullability(true) else it }
+    }
+
+internal fun KType.isSubtypeWithNullabilityOf(type: KType) =
+    this.isSubtypeOf(type) && (!this.isMarkedNullable || type.isMarkedNullable)
+
+@PublishedApi
+internal fun headPlusArray(head: Byte, cols: ByteArray): ByteArray = byteArrayOf(head) + cols
+
+@PublishedApi
+internal fun headPlusArray(head: Short, cols: ShortArray): ShortArray = shortArrayOf(head) + cols
+
+@PublishedApi
+internal fun headPlusArray(head: Int, cols: IntArray): IntArray = intArrayOf(head) + cols
+
+@PublishedApi
+internal fun headPlusArray(head: Long, cols: LongArray): LongArray = longArrayOf(head) + cols
+
+@PublishedApi
+internal fun headPlusArray(head: Float, cols: FloatArray): FloatArray = floatArrayOf(head) + cols
+
+@PublishedApi
+internal fun headPlusArray(head: Double, cols: DoubleArray): DoubleArray = doubleArrayOf(head) + cols
+
+@PublishedApi
+internal fun headPlusArray(head: Boolean, cols: BooleanArray): BooleanArray = booleanArrayOf(head) + cols
+
+@PublishedApi
+internal fun headPlusArray(head: Char, cols: CharArray): CharArray = charArrayOf(head) + cols
+
+@PublishedApi
+internal inline fun <reified C> headPlusArray(head: C, cols: Array<out C>): Array<C> =
+    (listOf(head) + cols.toList()).toTypedArray()
+
+@PublishedApi
+internal inline fun <reified C> headPlusIterable(head: C, cols: Iterable<C>): Iterable<C> =
+    (listOf(head) + cols.asIterable())
+
+internal fun <T> DataFrame<T>.splitByIndices(startIndices: Sequence<Int>): Sequence<DataFrame<T>> =
+    (startIndices + nrow).zipWithNext { start, endExclusive ->
+        if (start == endExclusive) {
+            DataFrame.empty().cast()
+        } else {
+            get(start until endExclusive)
+        }
+    }
+
+internal fun <T> List<T>.splitByIndices(startIndices: Sequence<Int>): Sequence<List<T>> =
+    (startIndices + size).zipWithNext { start, endExclusive ->
+        subList(start, endExclusive)
+    }
+
+internal fun <T> T.asNullable() = this as T?
+
+internal fun <T> List<T>.last(count: Int) = subList(size - count, size)
+
+internal fun <T : Comparable<T>> T.between(left: T, right: T, includeBoundaries: Boolean = true): Boolean =
+    if (includeBoundaries) {
+        this in left..right
+    } else {
+        this > left && this < right
+    }
+
+private const val DELIMITERS = "[_\\s]"
+public val DELIMITERS_REGEX: Regex = DELIMITERS.toRegex()
+public val DELIMITED_STRING_REGEX: Regex = ".+$DELIMITERS.+".toRegex()
+
+internal val CAMEL_REGEX = "(?<=[a-zA-Z])[A-Z]".toRegex()
+
+public fun String.toCamelCaseByDelimiters(delimiters: Regex): String = split(delimiters).joinToCamelCaseString()
+
+internal fun String.toSnakeCase(): String =
+    if ("[A-Z_]+".toRegex().matches(this)) {
+        this
+    } else {
+        CAMEL_REGEX
+            .replace(this) { "_${it.value}" }
+            .replace(" ", "_")
+            .lowercase()
+    }
+
+internal fun List<String>.joinToCamelCaseString(): String =
+    joinToString(separator = "") { it.replaceFirstChar { it.uppercaseChar() } }
+        .replaceFirstChar { it.lowercaseChar() }
+
+/** Returns `true` if this callable is a getter-like function.
+ *
+ * A callable is considered getter-like if it is either a property getter,
+ * or it's a function with no (type) parameters that starts with "get"/"is". */
+internal fun KFunction<*>.isGetterLike(): Boolean =
+    (name.startsWith("get") || name.startsWith("is")) &&
+        valueParameters.isEmpty() &&
+        typeParameters.isEmpty()
+
+/** Returns `true` if this callable is a getter-like function.
+ *
+ * A callable is considered getter-like if it is either a property getter,
+ * or it's a function with no (type) parameters that starts with "get"/"is". */
+internal fun KProperty<*>.isGetterLike(): Boolean = true
+
+/**
+ * Returns `true` if this callable is a getter-like function.
+ *
+ * A callable is considered getter-like if it is either a property getter,
+ * or it's a function with no (type) parameters that starts with "get"/"is".
+ */
+internal fun KCallable<*>.isGetterLike(): Boolean =
+    when (this) {
+        is KProperty<*> -> isGetterLike()
+        is KFunction<*> -> isGetterLike()
+        else -> false
+    }
+
+/** Returns the column name for this callable.
+ * If the callable contains the [ColumnName][org.jetbrains.kotlinx.dataframe.annotations.ColumnName] annotation, its [ColumnName.name][org.jetbrains.kotlinx.dataframe.annotations.ColumnName.name] is returned.
+ * Otherwise, the name of the callable is returned with proper getter-trimming if it's a [KFunction]. */
+@PublishedApi
+internal val KFunction<*>.columnName: String
+    get() = findAnnotation<ColumnName>()?.name
+        ?: name
+            .removePrefix("get")
+            .removePrefix("is")
+            .replaceFirstChar { it.lowercase() }
+
+/** Returns the column name for this callable.
+ * If the callable contains the [ColumnName][org.jetbrains.kotlinx.dataframe.annotations.ColumnName] annotation, its [ColumnName.name][org.jetbrains.kotlinx.dataframe.annotations.ColumnName.name] is returned.
+ * Otherwise, the name of the callable is returned with proper getter-trimming if it's a [KFunction]. */
+@PublishedApi
+internal val KProperty<*>.columnName: String
+    get() = findAnnotation<ColumnName>()?.name ?: name
+
+/**
+ * Returns the column name for this callable.
+ * If the callable contains the [ColumnName] annotation, its [ColumnName.name] is returned.
+ * Otherwise, the name of the callable is returned with proper getter-trimming if it's a [KFunction].
+ */
+@PublishedApi
+internal val KCallable<*>.columnName: String
+    get() = when (this) {
+        is KFunction<*> -> columnName
+        is KProperty<*> -> columnName
+        else -> findAnnotation<ColumnName>()?.name ?: name
+    }
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/aggregation/AggregatableInternal.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/aggregation/AggregatableInternal.kt
new file mode 100644
index 000000000..1008a410d
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/aggregation/AggregatableInternal.kt
@@ -0,0 +1,23 @@
+package org.jetbrains.kotlinx.dataframe.impl.aggregation
+
+import org.jetbrains.kotlinx.dataframe.ColumnsSelector
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.aggregation.Aggregatable
+import org.jetbrains.kotlinx.dataframe.aggregation.AggregateGroupedBody
+import org.jetbrains.kotlinx.dataframe.api.Grouped
+import org.jetbrains.kotlinx.dataframe.api.aggregate
+import org.jetbrains.kotlinx.dataframe.impl.aggregation.receivers.AggregateBodyInternal
+
+internal interface AggregatableInternal<out T> : Aggregatable<T> {
+
+    fun remainingColumnsSelector(): ColumnsSelector<*, *>
+}
+
+internal fun <T> Aggregatable<T>.remainingColumnsSelector() = internal().remainingColumnsSelector()
+
+@PublishedApi
+internal fun <T> Aggregatable<T>.internal(): AggregatableInternal<T> = this as AggregatableInternal<T>
+
+@PublishedApi
+internal fun <T, R> Grouped<T>.aggregateInternal(body: AggregateBodyInternal<T, R>): DataFrame<T> =
+    aggregate(body as AggregateGroupedBody<T, R>)
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/aggregation/AggregateColumnDescriptor.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/aggregation/AggregateColumnDescriptor.kt
new file mode 100644
index 000000000..3211e440a
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/aggregation/AggregateColumnDescriptor.kt
@@ -0,0 +1,34 @@
+package org.jetbrains.kotlinx.dataframe.impl.aggregation
+
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.aggregation.ColumnsForAggregateSelector
+import org.jetbrains.kotlinx.dataframe.columns.ColumnPath
+import org.jetbrains.kotlinx.dataframe.columns.ColumnWithPath
+import org.jetbrains.kotlinx.dataframe.columns.UnresolvedColumnsPolicy
+import org.jetbrains.kotlinx.dataframe.columns.shortPath
+import org.jetbrains.kotlinx.dataframe.impl.aggregation.receivers.AggregateInternalDsl
+import org.jetbrains.kotlinx.dataframe.impl.columns.resolve
+
+internal class AggregateColumnDescriptor<C>(
+    val column: ColumnWithPath<C>,
+    val default: C? = null,
+    val newPath: ColumnPath? = null,
+) : ColumnWithPath<C> by column
+
+internal fun <T, C> DataFrame<T>.getAggregateColumn(selector: ColumnsForAggregateSelector<T, C>) =
+    getAggregateColumns(selector).single()
+
+internal fun <T, C> DataFrame<T>.getAggregateColumns(
+    selector: ColumnsForAggregateSelector<T, C>,
+): List<AggregateColumnDescriptor<C>> {
+    val columns = selector.toColumns().resolve(this, UnresolvedColumnsPolicy.Create)
+    return columns.map {
+        when (val col = it) {
+            is AggregateColumnDescriptor<*> -> col as AggregateColumnDescriptor<C>
+            else -> AggregateColumnDescriptor(it, null, null)
+        }
+    }
+}
+
+internal fun <T, C> AggregateInternalDsl<T>.getPath(col: AggregateColumnDescriptor<C>, isSingle: Boolean) =
+    col.newPath ?: if (isSingle) pathForSingleColumn(col.data) else col.data.shortPath()
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/aggregation/ConfiguredAggregateColumn.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/aggregation/ConfiguredAggregateColumn.kt
new file mode 100644
index 000000000..22bf30d0f
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/aggregation/ConfiguredAggregateColumn.kt
@@ -0,0 +1,87 @@
+package org.jetbrains.kotlinx.dataframe.impl.aggregation
+
+import org.jetbrains.kotlinx.dataframe.columns.ColumnPath
+import org.jetbrains.kotlinx.dataframe.columns.ColumnResolutionContext
+import org.jetbrains.kotlinx.dataframe.columns.ColumnSet
+import org.jetbrains.kotlinx.dataframe.columns.ColumnWithPath
+import org.jetbrains.kotlinx.dataframe.columns.ColumnsResolver
+import org.jetbrains.kotlinx.dataframe.columns.SingleColumn
+import org.jetbrains.kotlinx.dataframe.columns.shortPath
+
+internal class ConfiguredAggregateColumn<C> private constructor(
+    val columns: ColumnsResolver<C>,
+    private val default: C? = null,
+    private val newPath: ColumnPath? = null,
+) : SingleColumn<C>,
+    ColumnSet<C> {
+
+    private fun ColumnWithPath<C>.toDescriptor(keepName: Boolean): AggregateColumnDescriptor<C> =
+        when (val col = this) {
+            is AggregateColumnDescriptor<C> -> {
+                // Fix for K2 smart-casting changes
+                val currentDefault = this@ConfiguredAggregateColumn.default
+                val currentNewPath = this@ConfiguredAggregateColumn.newPath
+
+                val newPath = when {
+                    currentNewPath == null -> col.newPath
+                    keepName -> currentNewPath + (col.newPath ?: col.column.shortPath())
+                    else -> currentNewPath
+                }
+                AggregateColumnDescriptor(
+                    column = col.column,
+                    default = currentDefault ?: col.default,
+                    newPath = newPath,
+                )
+            }
+
+            else ->
+                AggregateColumnDescriptor(
+                    column = col,
+                    default = default,
+                    newPath = if (keepName) newPath?.plus(col.name) else newPath,
+                )
+        }
+
+    private fun resolve(context: ColumnResolutionContext, columns: ColumnsResolver<C>): List<ColumnWithPath<C>> {
+        val resolved = columns.resolve(context)
+        return if (resolved.size == 1) {
+            listOf(resolved[0].toDescriptor(false))
+        } else {
+            resolved.map {
+                it.toDescriptor(true)
+            }
+        }
+    }
+
+    override fun resolve(context: ColumnResolutionContext): List<ColumnWithPath<C>> = resolve(context, columns)
+
+    override fun resolveSingle(context: ColumnResolutionContext): ColumnWithPath<C>? =
+        resolve(context, columns).singleOrNull()
+
+    companion object {
+
+        fun <C> withPath(src: SingleColumn<C>, newPath: ColumnPath): SingleColumn<C> =
+            when (src) {
+                is ConfiguredAggregateColumn<C> -> ConfiguredAggregateColumn(src.columns, src.default, newPath)
+                else -> ConfiguredAggregateColumn(src, null, newPath)
+            }
+
+        fun <C> withDefault(src: SingleColumn<C>, default: C?): SingleColumn<C> =
+            when (src) {
+                is ConfiguredAggregateColumn<C> -> ConfiguredAggregateColumn(src.columns, default, src.newPath)
+                else -> ConfiguredAggregateColumn(src, default, null)
+            }
+
+        fun <C> withPath(src: ColumnSet<C>, newPath: ColumnPath): ColumnSet<C> =
+            when (src) {
+                is ConfiguredAggregateColumn<C> -> ConfiguredAggregateColumn(src.columns, src.default, newPath)
+                else -> ConfiguredAggregateColumn(src, null, newPath)
+            }
+
+        fun <C> withDefault(src: ColumnSet<C>, default: C?): ColumnSet<C> =
+            when (src) {
+                is ConfiguredAggregateColumn<C> -> ConfiguredAggregateColumn(src.columns, default, src.newPath)
+                else -> ConfiguredAggregateColumn(src, default, null)
+            }
+    }
+}
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/aggregation/GroupByReceiverImpl.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/aggregation/GroupByReceiverImpl.kt
new file mode 100644
index 000000000..5272accd1
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/aggregation/GroupByReceiverImpl.kt
@@ -0,0 +1,140 @@
+package org.jetbrains.kotlinx.dataframe.impl.aggregation
+
+import org.jetbrains.kotlinx.dataframe.AnyCol
+import org.jetbrains.kotlinx.dataframe.AnyRow
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.aggregation.AggregateGroupedDsl
+import org.jetbrains.kotlinx.dataframe.aggregation.NamedValue
+import org.jetbrains.kotlinx.dataframe.api.asDataFrame
+import org.jetbrains.kotlinx.dataframe.api.toDataFrameFromPairs
+import org.jetbrains.kotlinx.dataframe.columns.ColumnGroup
+import org.jetbrains.kotlinx.dataframe.columns.ColumnPath
+import org.jetbrains.kotlinx.dataframe.columns.FrameColumn
+import org.jetbrains.kotlinx.dataframe.columns.ValueColumn
+import org.jetbrains.kotlinx.dataframe.columns.shortPath
+import org.jetbrains.kotlinx.dataframe.impl.aggregation.receivers.AggregateInternalDsl
+import org.jetbrains.kotlinx.dataframe.impl.api.AggregatedPivot
+import org.jetbrains.kotlinx.dataframe.impl.createStarProjectedType
+import org.jetbrains.kotlinx.dataframe.impl.createTypeWithArgument
+import org.jetbrains.kotlinx.dataframe.impl.getListType
+import kotlin.reflect.KType
+
+internal class GroupByReceiverImpl<T>(override val df: DataFrame<T>, override val hasGroupingKeys: Boolean) :
+    AggregateGroupedDsl<T>(),
+    AggregateInternalDsl<T>,
+    AggregatableInternal<T> by df as AggregatableInternal<T>,
+    DataFrame<T> by df {
+
+    private val values = mutableListOf<NamedValue>()
+
+    internal fun child(): GroupByReceiverImpl<T> {
+        val child = GroupByReceiverImpl(df, true)
+        values.add(NamedValue.aggregator(child))
+        return child
+    }
+
+    internal fun compute(): AnyRow? {
+        val allValues = mutableListOf<NamedValue>()
+        values.forEach {
+            when (it.value) {
+                is GroupByReceiverImpl<*> -> {
+                    it.value.values.forEach {
+                        allValues.add(it)
+                    }
+                }
+
+                is ValueColumn<*> -> {
+                    allValues.add(
+                        NamedValue.create(it.path, it.value.toList(), getListType(it.value.type()), emptyList<Unit>()),
+                    )
+                }
+
+                is ColumnGroup<*> -> {
+                    val frameType = it.value
+                        .type()
+                        .arguments
+                        .singleOrNull()
+                        ?.type
+                    allValues.add(
+                        NamedValue.create(
+                            path = it.path,
+                            value = it.value.asDataFrame(),
+                            type = DataFrame::class.createTypeWithArgument(frameType),
+                            defaultValue = DataFrame.Empty,
+                        ),
+                    )
+                }
+
+                is FrameColumn<*> -> {
+                    allValues.add(
+                        NamedValue.create(
+                            path = it.path,
+                            value = it.value.toList(),
+                            type = getListType(it.value.type()),
+                            defaultValue = emptyList<Unit>(),
+                        ),
+                    )
+                }
+
+                else -> {
+                    allValues.add(it)
+                }
+            }
+        }
+        val columns = allValues.map { it.toColumnWithPath() }
+        return if (columns.isEmpty()) {
+            null
+        } else {
+            columns.toDataFrameFromPairs<T>()[0]
+        }
+    }
+
+    override fun pathForSingleColumn(column: AnyCol) = column.shortPath()
+
+    override fun <R> yield(
+        path: ColumnPath,
+        value: R,
+        type: KType?,
+        default: R?,
+    ) = yield(path, value, type, default, false)
+
+    override fun yield(value: NamedValue): NamedValue {
+        when (value.value) {
+            is AggregatedPivot<*> -> {
+                val pivot = value.value
+                val dropFirstNameInPath =
+                    pivot.inward == true &&
+                        value.path.isNotEmpty() &&
+                        pivot.aggregator.values.distinctBy { it.path.firstOrNull() }.count() == 1
+                pivot.aggregator.values.forEach {
+                    val targetPath =
+                        if (dropFirstNameInPath && it.path.size > 0) {
+                            value.path + it.path.dropFirst()
+                        } else {
+                            value.path + it.path
+                        }
+
+                    yield(targetPath, it.value, it.type, it.default, it.guessType)
+                }
+                pivot.aggregator.values.clear()
+            }
+
+            is AggregateInternalDsl<*> -> {
+                // Attempt to create DataFrame<Type> from AggregateInternalDsl<Type>
+                val dfType = value.type?.arguments?.firstOrNull()?.type
+                    ?.let { DataFrame::class.createTypeWithArgument(it) }
+                    ?: DataFrame::class.createStarProjectedType(nullable = false)
+
+                yield(
+                    value.copy(
+                        value = value.value.df,
+                        type = dfType,
+                    ),
+                )
+            }
+
+            else -> values.add(value)
+        }
+        return value
+    }
+}
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/aggregation/PivotGroupByImpl.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/aggregation/PivotGroupByImpl.kt
new file mode 100644
index 000000000..7e7168e86
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/aggregation/PivotGroupByImpl.kt
@@ -0,0 +1,42 @@
+package org.jetbrains.kotlinx.dataframe.impl.aggregation
+
+import org.jetbrains.kotlinx.dataframe.ColumnsSelector
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.aggregation.AggregateBody
+import org.jetbrains.kotlinx.dataframe.api.GroupBy
+import org.jetbrains.kotlinx.dataframe.api.PivotColumnsSelector
+import org.jetbrains.kotlinx.dataframe.api.PivotGroupBy
+import org.jetbrains.kotlinx.dataframe.api.aggregate
+import org.jetbrains.kotlinx.dataframe.api.cast
+import org.jetbrains.kotlinx.dataframe.api.firstOrNull
+import org.jetbrains.kotlinx.dataframe.columns.toColumnSet
+import org.jetbrains.kotlinx.dataframe.impl.GroupByImpl
+import org.jetbrains.kotlinx.dataframe.impl.api.aggregatePivot
+import org.jetbrains.kotlinx.dataframe.impl.api.getPivotColumnPaths
+import org.jetbrains.kotlinx.dataframe.impl.columns.toColumnSet
+
+internal data class PivotGroupByImpl<T>(
+    val df: GroupBy<*, T>,
+    val columns: PivotColumnsSelector<T, *>,
+    val inward: Boolean?,
+    val default: Any? = null,
+) : PivotGroupBy<T>,
+    AggregatableInternal<T> {
+    override fun <R> aggregate(separate: Boolean, body: AggregateBody<T, R>): DataFrame<T> =
+        df.aggregate {
+            aggregatePivot(this as GroupByReceiverImpl<T>, columns, separate, inward, default, body)
+        }.cast()
+
+    override fun default(value: Any?) = copy(default = value)
+
+    override fun remainingColumnsSelector(): ColumnsSelector<*, *> =
+        df.groups.firstOrNull()
+            ?.getPivotColumnPaths(columns).orEmpty()
+            .let { pivotPaths ->
+                {
+                    all().except(
+                        pivotPaths.toColumnSet() and (df as GroupByImpl).keyColumnsInGroups.toColumnSet(),
+                    )
+                }
+            }
+}
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/aggregation/PivotImpl.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/aggregation/PivotImpl.kt
new file mode 100644
index 000000000..2a3bc9367
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/aggregation/PivotImpl.kt
@@ -0,0 +1,20 @@
+package org.jetbrains.kotlinx.dataframe.impl.aggregation
+
+import org.jetbrains.kotlinx.dataframe.ColumnsSelector
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.api.Pivot
+import org.jetbrains.kotlinx.dataframe.api.PivotColumnsSelector
+import org.jetbrains.kotlinx.dataframe.api.PivotGroupBy
+import org.jetbrains.kotlinx.dataframe.api.groupBy
+import org.jetbrains.kotlinx.dataframe.impl.columns.toColumnSet
+
+internal data class PivotImpl<T>(val df: DataFrame<T>, val columns: PivotColumnsSelector<T, *>, val inward: Boolean?) :
+    Pivot<T>,
+    AggregatableInternal<T> {
+
+    fun toGroupedPivot(moveToTop: Boolean, columns: ColumnsSelector<T, *>): PivotGroupBy<T> =
+        PivotGroupByImpl(df.groupBy(moveToTop, columns), this.columns, inward)
+
+    override fun remainingColumnsSelector(): ColumnsSelector<*, *> =
+        columns.toColumnSet().let { pivotCols -> { all().except(pivotCols) } }
+}
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/aggregation/PivotInAggregateImpl.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/aggregation/PivotInAggregateImpl.kt
new file mode 100644
index 000000000..ecb81b6dc
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/aggregation/PivotInAggregateImpl.kt
@@ -0,0 +1,32 @@
+package org.jetbrains.kotlinx.dataframe.impl.aggregation
+
+import org.jetbrains.kotlinx.dataframe.ColumnsSelector
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.aggregation.AggregateBody
+import org.jetbrains.kotlinx.dataframe.aggregation.AggregateGroupedDsl
+import org.jetbrains.kotlinx.dataframe.api.PivotColumnsSelector
+import org.jetbrains.kotlinx.dataframe.api.PivotGroupBy
+import org.jetbrains.kotlinx.dataframe.impl.api.AggregatedPivot
+import org.jetbrains.kotlinx.dataframe.impl.api.aggregatePivot
+import org.jetbrains.kotlinx.dataframe.impl.columns.toColumnSet
+
+internal data class PivotInAggregateImpl<T>(
+    val aggregator: AggregateGroupedDsl<T>,
+    val columns: PivotColumnsSelector<T, *>,
+    val inward: Boolean?,
+    val default: Any? = null,
+) : PivotGroupBy<T>,
+    AggregatableInternal<T> {
+
+    override fun default(value: Any?) = copy(default = value)
+
+    override fun <R> aggregate(separate: Boolean, body: AggregateBody<T, R>): DataFrame<T> {
+        require(aggregator is GroupByReceiverImpl<T>)
+
+        val childAggregator = aggregator.child()
+        aggregatePivot(childAggregator, columns, separate, inward, default, body)
+        return AggregatedPivot(aggregator.df, inward, childAggregator)
+    }
+
+    override fun remainingColumnsSelector(): ColumnsSelector<*, *> = { all().except(columns.toColumnSet()) }
+}
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/aggregation/ValueWithDefault.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/aggregation/ValueWithDefault.kt
new file mode 100644
index 000000000..30353b226
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/aggregation/ValueWithDefault.kt
@@ -0,0 +1,3 @@
+package org.jetbrains.kotlinx.dataframe.impl.aggregation
+
+internal class ValueWithDefault<T>(val value: T, val default: T)
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/aggregation/aggregations.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/aggregation/aggregations.kt
new file mode 100644
index 000000000..67809f6da
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/aggregation/aggregations.kt
@@ -0,0 +1,104 @@
+package org.jetbrains.kotlinx.dataframe.impl.aggregation
+
+import org.jetbrains.kotlinx.dataframe.AnyColumnReference
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.DataRow
+import org.jetbrains.kotlinx.dataframe.RowExpression
+import org.jetbrains.kotlinx.dataframe.Selector
+import org.jetbrains.kotlinx.dataframe.aggregation.AggregateDsl
+import org.jetbrains.kotlinx.dataframe.aggregation.ColumnsForAggregateSelectionDsl
+import org.jetbrains.kotlinx.dataframe.aggregation.ColumnsForAggregateSelector
+import org.jetbrains.kotlinx.dataframe.api.asSequence
+import org.jetbrains.kotlinx.dataframe.api.canHaveNA
+import org.jetbrains.kotlinx.dataframe.api.cast
+import org.jetbrains.kotlinx.dataframe.api.isNA
+import org.jetbrains.kotlinx.dataframe.api.rows
+import org.jetbrains.kotlinx.dataframe.columns.ColumnPath
+import org.jetbrains.kotlinx.dataframe.columns.ColumnSet
+import org.jetbrains.kotlinx.dataframe.columns.UnresolvedColumnsPolicy
+import org.jetbrains.kotlinx.dataframe.impl.DataFrameReceiver
+import org.jetbrains.kotlinx.dataframe.impl.aggregation.receivers.AggregateInternalDsl
+import org.jetbrains.kotlinx.dataframe.impl.columns.toColumnSet
+import org.jetbrains.kotlinx.dataframe.impl.getListType
+import org.jetbrains.kotlinx.dataframe.type
+import org.jetbrains.kotlinx.dataframe.values
+import kotlin.reflect.KType
+import kotlin.reflect.full.withNullability
+
+@PublishedApi
+internal fun <T, V> AggregateInternalDsl<T>.yieldOneOrMany(
+    path: ColumnPath,
+    values: List<V>,
+    type: KType,
+    default: V? = null,
+) {
+    when (values.size) {
+        0 -> yield(path, null, type.withNullability(true), default)
+        1 -> yield(path, values[0], type, default)
+        else -> yield(path, values, getListType(type), default)
+    }
+}
+
+@JvmName("toColumnSetForAggregate")
+internal fun <T, C> ColumnsForAggregateSelector<T, C>.toColumns(): ColumnSet<C> =
+    toColumnSet {
+        object : DataFrameReceiver<T>(it.df.cast(), UnresolvedColumnsPolicy.Fail), ColumnsForAggregateSelectionDsl<T> {}
+    }
+
+@PublishedApi
+internal fun <T> AggregateDsl<T>.internal(): AggregateInternalDsl<T> = this as AggregateInternalDsl<T>
+
+internal fun <T, C> AggregateInternalDsl<T>.columnValues(
+    columns: ColumnsForAggregateSelector<T, C>,
+    forceYieldLists: Boolean,
+    dropNA: Boolean,
+    distinct: Boolean,
+) {
+    val cols = df.getAggregateColumns(columns)
+    val isSingle = cols.size == 1
+    cols.forEach { col ->
+        val path = getPath(col, isSingle)
+
+        val effectiveDropNA = if (dropNA) col.canHaveNA else false
+        // TODO: use Set for distinct values
+        val values = when {
+            effectiveDropNA && distinct -> col.asSequence().filter { !it.isNA }.distinct().toList()
+            effectiveDropNA && !distinct -> col.values.filter { !it.isNA }
+            distinct -> col.values().distinct()
+            else -> col.toList()
+        }
+
+        if (forceYieldLists) {
+            yield(path, values, getListType(col.type), col.default)
+        } else {
+            yieldOneOrMany(path, values, col.type, col.default)
+        }
+    }
+}
+
+internal fun <T, C> AggregateInternalDsl<T>.columnValues(
+    columns: ColumnsForAggregateSelector<T, C>,
+    reducer: Selector<DataFrame<T>, DataRow<T>?>,
+) {
+    val row = reducer(df, df)
+    val cols = df.getAggregateColumns(columns)
+    val isSingle = cols.size == 1
+    cols.forEach { col ->
+        val path = getPath(col, isSingle)
+        val value = if (row != null) col[row] else null
+        yield(path, value, col.type, col.default)
+    }
+}
+
+@PublishedApi
+internal fun <T, V> AggregateInternalDsl<T>.withExpr(type: KType, path: ColumnPath, expression: RowExpression<T, V>) {
+    val values = df.rows().map {
+        val value = expression(it, it)
+        if (value is AnyColumnReference) {
+            it[value]
+        } else {
+            value
+        }
+    }
+    yieldOneOrMany(path, values, type)
+}
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/aggregation/aggregators/Aggregator.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/aggregation/aggregators/Aggregator.kt
new file mode 100644
index 000000000..dcd88a15a
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/aggregation/aggregators/Aggregator.kt
@@ -0,0 +1,24 @@
+package org.jetbrains.kotlinx.dataframe.impl.aggregation.aggregators
+
+import org.jetbrains.kotlinx.dataframe.DataColumn
+import kotlin.reflect.KType
+
+@PublishedApi
+internal interface Aggregator<C, R> {
+
+    val name: String
+
+    fun aggregate(column: DataColumn<C?>): R?
+
+    val preservesType: Boolean
+
+    fun aggregate(columns: Iterable<DataColumn<C?>>): R?
+
+    fun aggregate(values: Iterable<C>, type: KType): R?
+}
+
+@PublishedApi
+internal fun <T> Aggregator<*, *>.cast(): Aggregator<T, T> = this as Aggregator<T, T>
+
+@PublishedApi
+internal fun <T, P> Aggregator<*, *>.cast2(): Aggregator<T, P> = this as Aggregator<T, P>
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/aggregation/aggregators/AggregatorBase.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/aggregation/aggregators/AggregatorBase.kt
new file mode 100644
index 000000000..1deb052b2
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/aggregation/aggregators/AggregatorBase.kt
@@ -0,0 +1,21 @@
+package org.jetbrains.kotlinx.dataframe.impl.aggregation.aggregators
+
+import org.jetbrains.kotlinx.dataframe.DataColumn
+import org.jetbrains.kotlinx.dataframe.api.asIterable
+import org.jetbrains.kotlinx.dataframe.api.asSequence
+import kotlin.reflect.KType
+
+internal abstract class AggregatorBase<C, R>(
+    override val name: String,
+    protected val aggregator: (Iterable<C>, KType) -> R?,
+) : Aggregator<C, R> {
+
+    override fun aggregate(column: DataColumn<C?>): R? =
+        if (column.hasNulls()) {
+            aggregate(column.asSequence().filterNotNull().asIterable(), column.type())
+        } else {
+            aggregate(column.asIterable() as Iterable<C>, column.type())
+        }
+
+    override fun aggregate(values: Iterable<C>, type: KType): R? = aggregator(values, type)
+}
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/aggregation/aggregators/AggregatorOptionSwitch.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/aggregation/aggregators/AggregatorOptionSwitch.kt
new file mode 100644
index 000000000..45cb01be1
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/aggregation/aggregators/AggregatorOptionSwitch.kt
@@ -0,0 +1,33 @@
+package org.jetbrains.kotlinx.dataframe.impl.aggregation.aggregators
+
+import kotlin.reflect.KProperty
+
+@PublishedApi
+internal class AggregatorOptionSwitch<P, C, R>(val name: String, val getAggregator: (P) -> AggregatorProvider<C, R>) {
+
+    private val cache = mutableMapOf<P, Aggregator<C, R>>()
+
+    operator fun invoke(option: P) = cache.getOrPut(option) { getAggregator(option).create(name) }
+
+    class Factory<P, C, R>(val getAggregator: (P) -> AggregatorProvider<C, R>) {
+        operator fun getValue(obj: Any?, property: KProperty<*>) = AggregatorOptionSwitch(property.name, getAggregator)
+    }
+}
+
+@PublishedApi
+internal class AggregatorOptionSwitch2<P1, P2, C, R>(
+    val name: String,
+    val getAggregator: (P1, P2) -> AggregatorProvider<C, R>,
+) {
+
+    private val cache = mutableMapOf<Pair<P1, P2>, Aggregator<C, R>>()
+
+    operator fun invoke(option1: P1, option2: P2) =
+        cache.getOrPut(option1 to option2) {
+            getAggregator(option1, option2).create(name)
+        }
+
+    class Factory<P1, P2, C, R>(val getAggregator: (P1, P2) -> AggregatorProvider<C, R>) {
+        operator fun getValue(obj: Any?, property: KProperty<*>) = AggregatorOptionSwitch2(property.name, getAggregator)
+    }
+}
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/aggregation/aggregators/AggregatorProvider.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/aggregation/aggregators/AggregatorProvider.kt
new file mode 100644
index 000000000..a8265a817
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/aggregation/aggregators/AggregatorProvider.kt
@@ -0,0 +1,10 @@
+package org.jetbrains.kotlinx.dataframe.impl.aggregation.aggregators
+
+import kotlin.reflect.KProperty
+
+internal interface AggregatorProvider<C, R> {
+
+    operator fun getValue(obj: Any?, property: KProperty<*>): Aggregator<C, R> = create(property.name)
+
+    fun create(name: String): Aggregator<C, R>
+}
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/aggregation/aggregators/Aggregators.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/aggregation/aggregators/Aggregators.kt
new file mode 100644
index 000000000..81ea4424c
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/aggregation/aggregators/Aggregators.kt
@@ -0,0 +1,48 @@
+package org.jetbrains.kotlinx.dataframe.impl.aggregation.aggregators
+
+import org.jetbrains.kotlinx.dataframe.impl.aggregation.aggregators.Aggregators.std
+import org.jetbrains.kotlinx.dataframe.math.mean
+import org.jetbrains.kotlinx.dataframe.math.median
+import org.jetbrains.kotlinx.dataframe.math.std
+import org.jetbrains.kotlinx.dataframe.math.sum
+import kotlin.reflect.KType
+
+@PublishedApi
+internal object Aggregators {
+
+    private fun <C> preservesType(aggregate: Iterable<C>.(KType) -> C?) =
+        TwoStepAggregator.Factory(aggregate, aggregate, true)
+
+    private fun <C : Any, R> mergedValues(aggregate: Iterable<C?>.(KType) -> R?) =
+        MergedValuesAggregator.Factory(aggregate, true)
+
+    private fun <C : Any, R> mergedValuesChangingTypes(aggregate: Iterable<C?>.(KType) -> R?) =
+        MergedValuesAggregator.Factory(aggregate, false)
+
+    private fun <C, R> changesType(aggregate1: Iterable<C>.(KType) -> R, aggregate2: Iterable<R>.(KType) -> R) =
+        TwoStepAggregator.Factory(aggregate1, aggregate2, false)
+
+    private fun extendsNumbers(aggregate: Iterable<Number>.(KType) -> Number?) = NumbersAggregator.Factory(aggregate)
+
+    private fun <P, C, R> withOption(getAggregator: (P) -> AggregatorProvider<C, R>) =
+        AggregatorOptionSwitch.Factory(getAggregator)
+
+    private fun <P1, P2, C, R> withOption2(getAggregator: (P1, P2) -> AggregatorProvider<C, R>) =
+        AggregatorOptionSwitch2.Factory(getAggregator)
+
+    val min by preservesType<Comparable<Any?>> { minOrNull() }
+
+    val max by preservesType<Comparable<Any?>> { maxOrNull() }
+
+    val std by withOption2<Boolean, Int, Number, Double> { skipNA, ddof ->
+        mergedValuesChangingTypes { std(it, skipNA, ddof) }
+    }
+
+    val mean by withOption<Boolean, Number, Double> { skipNA ->
+        changesType({ mean(it, skipNA) }) { mean(skipNA) }
+    }
+
+    val median by mergedValues<Comparable<Any?>, Comparable<Any?>> { median(it) }
+
+    val sum by extendsNumbers { sum(it) }
+}
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/aggregation/aggregators/MergedValuesAggregator.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/aggregation/aggregators/MergedValuesAggregator.kt
new file mode 100644
index 000000000..135ba0a5e
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/aggregation/aggregators/MergedValuesAggregator.kt
@@ -0,0 +1,42 @@
+package org.jetbrains.kotlinx.dataframe.impl.aggregation.aggregators
+
+import org.jetbrains.kotlinx.dataframe.DataColumn
+import org.jetbrains.kotlinx.dataframe.impl.commonType
+import kotlin.reflect.KProperty
+import kotlin.reflect.KType
+
+internal class MergedValuesAggregator<C : Any, R>(
+    name: String,
+    val aggregateWithType: (Iterable<C?>, KType) -> R?,
+    override val preservesType: Boolean,
+) : AggregatorBase<C, R>(name, aggregateWithType) {
+
+    override fun aggregate(columns: Iterable<DataColumn<C?>>): R? {
+        val commonType = columns.map { it.type() }.commonType()
+        val allValues = columns.flatMap { it.values() }
+        return aggregateWithType(allValues, commonType)
+    }
+
+    fun aggregateMixed(values: Iterable<C?>): R? {
+        var hasNulls = false
+        val classes = values.mapNotNull {
+            if (it == null) {
+                hasNulls = true
+                null
+            } else {
+                it.javaClass.kotlin
+            }
+        }
+        return aggregateWithType(values, classes.commonType(hasNulls))
+    }
+
+    class Factory<C : Any, R>(
+        private val aggregateWithType: (Iterable<C?>, KType) -> R?,
+        private val preservesType: Boolean,
+    ) : AggregatorProvider<C, R> {
+        override fun create(name: String) = MergedValuesAggregator(name, aggregateWithType, preservesType)
+
+        override operator fun getValue(obj: Any?, property: KProperty<*>): MergedValuesAggregator<C, R> =
+            create(property.name)
+    }
+}
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/aggregation/aggregators/NumbersAggregator.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/aggregation/aggregators/NumbersAggregator.kt
new file mode 100644
index 000000000..db99322cc
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/aggregation/aggregators/NumbersAggregator.kt
@@ -0,0 +1,27 @@
+package org.jetbrains.kotlinx.dataframe.impl.aggregation.aggregators
+
+import org.jetbrains.kotlinx.dataframe.DataColumn
+import org.jetbrains.kotlinx.dataframe.impl.commonNumberClass
+import org.jetbrains.kotlinx.dataframe.impl.createStarProjectedType
+import kotlin.reflect.KProperty
+import kotlin.reflect.KType
+
+internal class NumbersAggregator<C : Number>(name: String, aggregate: (Iterable<C>, KType) -> C?) :
+    AggregatorBase<C, C>(name, aggregate) {
+
+    override fun aggregate(columns: Iterable<DataColumn<C?>>): C? = aggregateMixed(columns.mapNotNull { aggregate(it) })
+
+    class Factory(private val aggregate: Iterable<Number>.(KType) -> Number?) : AggregatorProvider<Number, Number> {
+        override fun create(name: String) = NumbersAggregator(name, aggregate)
+
+        override operator fun getValue(obj: Any?, property: KProperty<*>): NumbersAggregator<Number> =
+            create(property.name)
+    }
+
+    fun aggregateMixed(values: Iterable<C>): C? {
+        val classes = values.map { it.javaClass.kotlin }
+        return aggregate(values, classes.commonNumberClass().createStarProjectedType(false))
+    }
+
+    override val preservesType = false
+}
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/aggregation/aggregators/TwoStepAggregator.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/aggregation/aggregators/TwoStepAggregator.kt
new file mode 100644
index 000000000..9d01169d0
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/aggregation/aggregators/TwoStepAggregator.kt
@@ -0,0 +1,27 @@
+package org.jetbrains.kotlinx.dataframe.impl.aggregation.aggregators
+
+import org.jetbrains.kotlinx.dataframe.DataColumn
+import org.jetbrains.kotlinx.dataframe.impl.commonType
+import kotlin.reflect.KType
+
+internal class TwoStepAggregator<C, R>(
+    name: String,
+    aggregateWithType: (Iterable<C>, KType) -> R?,
+    private val aggregateValues: (Iterable<R>, KType) -> R?,
+    override val preservesType: Boolean,
+) : AggregatorBase<C, R>(name, aggregateWithType) {
+
+    override fun aggregate(columns: Iterable<DataColumn<C?>>): R? {
+        val columnValues = columns.mapNotNull { aggregate(it) }
+        val commonType = columnValues.map { it.javaClass.kotlin }.commonType(false)
+        return aggregateValues(columnValues, commonType)
+    }
+
+    class Factory<C, R>(
+        private val aggregateWithType: (Iterable<C>, KType) -> R?,
+        private val aggregateValues: (Iterable<R>, KType) -> R?,
+        private val preservesType: Boolean,
+    ) : AggregatorProvider<C, R> {
+        override fun create(name: String) = TwoStepAggregator(name, aggregateWithType, aggregateValues, preservesType)
+    }
+}
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/aggregation/getColumns.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/aggregation/getColumns.kt
new file mode 100644
index 000000000..46dd1129f
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/aggregation/getColumns.kt
@@ -0,0 +1,28 @@
+package org.jetbrains.kotlinx.dataframe.impl.aggregation
+
+import org.jetbrains.kotlinx.dataframe.AnyCol
+import org.jetbrains.kotlinx.dataframe.ColumnsSelector
+import org.jetbrains.kotlinx.dataframe.aggregation.Aggregatable
+import org.jetbrains.kotlinx.dataframe.aggregation.NamedValue
+import org.jetbrains.kotlinx.dataframe.api.filter
+import org.jetbrains.kotlinx.dataframe.api.isComparable
+import org.jetbrains.kotlinx.dataframe.api.isNumber
+import org.jetbrains.kotlinx.dataframe.impl.columns.guessColumnType
+
+internal inline fun <T> Aggregatable<T>.remainingColumns(
+    crossinline predicate: (AnyCol) -> Boolean,
+): ColumnsSelector<T, Any?> = remainingColumnsSelector().filter { predicate(it.data) }
+
+internal fun <T> Aggregatable<T>.comparableColumns() =
+    remainingColumns { it.isComparable() } as ColumnsSelector<T, Comparable<Any?>>
+
+internal fun <T> Aggregatable<T>.numberColumns() = remainingColumns { it.isNumber() } as ColumnsSelector<T, Number?>
+
+internal fun NamedValue.toColumnWithPath() =
+    path to guessColumnType(
+        name = path.last(),
+        values = listOf(value),
+        suggestedType = type,
+        suggestedTypeIsUpperBound = guessType,
+        defaultValue = default,
+    )
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/aggregation/modes/aggregateBy.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/aggregation/modes/aggregateBy.kt
new file mode 100644
index 000000000..239ed236d
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/aggregation/modes/aggregateBy.kt
@@ -0,0 +1,21 @@
+package org.jetbrains.kotlinx.dataframe.impl.aggregation.modes
+
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.DataFrameExpression
+import org.jetbrains.kotlinx.dataframe.DataRow
+import org.jetbrains.kotlinx.dataframe.api.GroupBy
+import org.jetbrains.kotlinx.dataframe.api.Grouped
+import org.jetbrains.kotlinx.dataframe.api.cast
+import org.jetbrains.kotlinx.dataframe.impl.aggregation.aggregateInternal
+import org.jetbrains.kotlinx.dataframe.impl.namedValues
+
+internal fun <T> Grouped<T>.aggregateBy(body: DataFrameExpression<T, DataRow<T>?>): DataFrame<T> {
+    require(this is GroupBy<*, T>)
+    val keyColumns = keys.columnNames().toSet()
+    return aggregateInternal {
+        val row = body(df, df)
+        row?.namedValues()?.forEach {
+            if (!keyColumns.contains(it.name)) yield(it)
+        }
+    }.cast()
+}
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/aggregation/modes/forEveryColumn.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/aggregation/modes/forEveryColumn.kt
new file mode 100644
index 000000000..fbb932e03
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/aggregation/modes/forEveryColumn.kt
@@ -0,0 +1,54 @@
+package org.jetbrains.kotlinx.dataframe.impl.aggregation.modes
+
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.DataRow
+import org.jetbrains.kotlinx.dataframe.aggregation.ColumnsForAggregateSelector
+import org.jetbrains.kotlinx.dataframe.api.Grouped
+import org.jetbrains.kotlinx.dataframe.api.PivotGroupBy
+import org.jetbrains.kotlinx.dataframe.impl.aggregation.aggregateInternal
+import org.jetbrains.kotlinx.dataframe.impl.aggregation.aggregators.Aggregator
+import org.jetbrains.kotlinx.dataframe.impl.aggregation.aggregators.cast
+import org.jetbrains.kotlinx.dataframe.impl.aggregation.getAggregateColumns
+import org.jetbrains.kotlinx.dataframe.impl.aggregation.getPath
+import org.jetbrains.kotlinx.dataframe.impl.aggregation.internal
+import org.jetbrains.kotlinx.dataframe.impl.aggregation.receivers.AggregateInternalDsl
+import org.jetbrains.kotlinx.dataframe.type
+
+internal fun <T, C, R> Aggregator<*, R>.aggregateFor(
+    data: Grouped<T>,
+    columns: ColumnsForAggregateSelector<T, C?>,
+): DataFrame<T> =
+    data.aggregateInternal {
+        aggregateFor(columns, cast())
+    }
+
+internal fun <T, C, R> Aggregator<*, R>.aggregateFor(
+    data: PivotGroupBy<T>,
+    separate: Boolean,
+    columns: ColumnsForAggregateSelector<T, C?>,
+): DataFrame<T> =
+    data.aggregate(separate) {
+        internal().aggregateFor(columns, cast())
+    }
+
+internal fun <T, C, R> Aggregator<*, R>.aggregateFor(
+    data: DataFrame<T>,
+    columns: ColumnsForAggregateSelector<T, C?>,
+): DataRow<T> =
+    data.aggregate {
+        internal().aggregateFor(columns, cast())
+    }
+
+internal fun <T, C, R> AggregateInternalDsl<T>.aggregateFor(
+    columns: ColumnsForAggregateSelector<T, C>,
+    aggregator: Aggregator<C, R>,
+) {
+    val cols = df.getAggregateColumns(columns)
+    val isSingle = cols.size == 1
+    cols.forEach { col ->
+        val path = getPath(col, isSingle)
+        val value = aggregator.aggregate(col.data)
+        val inferType = !aggregator.preservesType
+        yield(path, value, col.type, col.default, inferType)
+    }
+}
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/aggregation/modes/noAggregation.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/aggregation/modes/noAggregation.kt
new file mode 100644
index 000000000..8af329a13
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/aggregation/modes/noAggregation.kt
@@ -0,0 +1,15 @@
+package org.jetbrains.kotlinx.dataframe.impl.aggregation.modes
+
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.aggregation.AggregateBody
+import org.jetbrains.kotlinx.dataframe.api.Grouped
+import org.jetbrains.kotlinx.dataframe.api.pathOf
+import org.jetbrains.kotlinx.dataframe.impl.aggregation.aggregateInternal
+import org.jetbrains.kotlinx.dataframe.impl.aggregation.receivers.internal
+
+@PublishedApi
+internal fun <T, R> Grouped<T>.aggregateValue(resultName: String, body: AggregateBody<T, R>): DataFrame<T> =
+    aggregateInternal {
+        val value = body.internal()(this)
+        yield(pathOf(resultName), value)
+    }
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/aggregation/modes/ofRowExpression.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/aggregation/modes/ofRowExpression.kt
new file mode 100644
index 000000000..4d43fb612
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/aggregation/modes/ofRowExpression.kt
@@ -0,0 +1,89 @@
+package org.jetbrains.kotlinx.dataframe.impl.aggregation.modes
+
+import org.jetbrains.kotlinx.dataframe.DataColumn
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.RowExpression
+import org.jetbrains.kotlinx.dataframe.aggregation.AggregateBody
+import org.jetbrains.kotlinx.dataframe.api.Grouped
+import org.jetbrains.kotlinx.dataframe.api.PivotGroupBy
+import org.jetbrains.kotlinx.dataframe.api.pathOf
+import org.jetbrains.kotlinx.dataframe.api.rows
+import org.jetbrains.kotlinx.dataframe.impl.aggregation.aggregateInternal
+import org.jetbrains.kotlinx.dataframe.impl.aggregation.aggregators.Aggregator
+import org.jetbrains.kotlinx.dataframe.impl.aggregation.internal
+import org.jetbrains.kotlinx.dataframe.impl.emptyPath
+import kotlin.reflect.typeOf
+
+@PublishedApi
+internal inline fun <C, reified V, R> Aggregator<V, R>.aggregateOf(
+    values: Iterable<C>,
+    noinline transform: (C) -> V,
+): R? = aggregate(values.asSequence().map(transform).asIterable(), typeOf<V>())
+
+@PublishedApi
+internal inline fun <C, reified V, R> Aggregator<V, R>.aggregateOf(
+    column: DataColumn<C>,
+    noinline transform: (C) -> V,
+): R? = aggregateOf(column.values(), transform)
+
+@PublishedApi
+internal inline fun <T, reified C, R> Aggregator<*, R>.aggregateOf(
+    frame: DataFrame<T>,
+    crossinline expression: RowExpression<T, C>,
+): R? = (this as Aggregator<C, R>).aggregateOf(frame.rows()) { expression(it, it) } // TODO: inline
+
+@PublishedApi
+internal fun <T, C, R> Aggregator<*, R>.aggregateOfDelegated(
+    frame: Grouped<T>,
+    name: String?,
+    body: AggregateBody<T, C>,
+): DataFrame<T> =
+    frame.aggregateValue(name ?: this.name) {
+        body(this, this)
+    }
+
+@PublishedApi
+internal inline fun <T, reified C, R> Aggregator<*, R>.of(
+    data: DataFrame<T>,
+    crossinline expression: RowExpression<T, C>,
+): R? = aggregateOf(data as DataFrame<T>, expression)
+
+@PublishedApi
+internal inline fun <C, reified V, R> Aggregator<V, R>.of(data: DataColumn<C>, crossinline expression: (C) -> V): R? =
+    aggregateOf(data.values()) { expression(it) } // TODO: inline
+
+@PublishedApi
+internal inline fun <T, reified C, reified R> Aggregator<*, R>.aggregateOf(
+    data: Grouped<T>,
+    resultName: String? = null,
+    crossinline expression: RowExpression<T, C>,
+): DataFrame<T> = data.aggregateOf(resultName, expression, this as Aggregator<C, R>)
+
+@PublishedApi
+internal inline fun <T, reified C, reified R> Aggregator<*, R>.aggregateOf(
+    data: PivotGroupBy<T>,
+    crossinline expression: RowExpression<T, C>,
+): DataFrame<T> = data.aggregateOf(expression, this as Aggregator<C, R>)
+
+@PublishedApi
+internal inline fun <T, reified C, reified R> Grouped<T>.aggregateOf(
+    resultName: String?,
+    crossinline expression: RowExpression<T, C>,
+    aggregator: Aggregator<C, R>,
+): DataFrame<T> {
+    val path = pathOf(resultName ?: aggregator.name)
+    val type = typeOf<R>()
+    return aggregateInternal {
+        val value = aggregator.aggregateOf(df, expression)
+        yield(path, value, type, null, false)
+    }
+}
+
+@PublishedApi
+internal inline fun <T, reified C, R> PivotGroupBy<T>.aggregateOf(
+    crossinline expression: RowExpression<T, C>,
+    aggregator: Aggregator<C, R>,
+): DataFrame<T> =
+    aggregate {
+        internal().yield(emptyPath(), aggregator.aggregateOf(this, expression))
+    }
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/aggregation/modes/withinAllColumns.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/aggregation/modes/withinAllColumns.kt
new file mode 100644
index 000000000..c6edf1400
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/aggregation/modes/withinAllColumns.kt
@@ -0,0 +1,59 @@
+package org.jetbrains.kotlinx.dataframe.impl.aggregation.modes
+
+import org.jetbrains.kotlinx.dataframe.ColumnsSelector
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.api.Grouped
+import org.jetbrains.kotlinx.dataframe.api.PivotGroupBy
+import org.jetbrains.kotlinx.dataframe.api.pathOf
+import org.jetbrains.kotlinx.dataframe.get
+import org.jetbrains.kotlinx.dataframe.impl.aggregation.aggregateInternal
+import org.jetbrains.kotlinx.dataframe.impl.aggregation.aggregators.Aggregator
+import org.jetbrains.kotlinx.dataframe.impl.aggregation.aggregators.cast
+import org.jetbrains.kotlinx.dataframe.impl.aggregation.aggregators.cast2
+import org.jetbrains.kotlinx.dataframe.impl.aggregation.internal
+import org.jetbrains.kotlinx.dataframe.impl.emptyPath
+
+@PublishedApi
+internal fun <T, C, R> Aggregator<*, R>.aggregateAll(data: DataFrame<T>, columns: ColumnsSelector<T, C>): R? =
+    data.aggregateAll(cast2(), columns)
+
+internal fun <T, R, C> Aggregator<*, R>.aggregateAll(
+    data: Grouped<T>,
+    name: String?,
+    columns: ColumnsSelector<T, C>,
+): DataFrame<T> = data.aggregateAll(cast(), columns, name)
+
+internal fun <T, R, C> Aggregator<*, R>.aggregateAll(
+    data: PivotGroupBy<T>,
+    columns: ColumnsSelector<T, C>,
+): DataFrame<T> = data.aggregateAll(cast(), columns)
+
+internal fun <T, C, R> DataFrame<T>.aggregateAll(aggregator: Aggregator<C, R>, columns: ColumnsSelector<T, C?>): R? =
+    aggregator.aggregate(get(columns))
+
+internal fun <T, C, R> Grouped<T>.aggregateAll(
+    aggregator: Aggregator<C, R>,
+    columns: ColumnsSelector<T, C>,
+    name: String?,
+): DataFrame<T> =
+    aggregateInternal {
+        val cols = df[columns]
+        if (cols.size == 1) {
+            yield(pathOf(name ?: cols[0].name()), aggregator.aggregate(cols[0]))
+        } else {
+            yield(pathOf(name ?: aggregator.name), aggregator.aggregate(cols))
+        }
+    }
+
+internal fun <T, C, R> PivotGroupBy<T>.aggregateAll(
+    aggregator: Aggregator<C, R>,
+    columns: ColumnsSelector<T, C>,
+): DataFrame<T> =
+    aggregate {
+        val cols = get(columns)
+        if (cols.size == 1) {
+            internal().yield(emptyPath(), aggregator.aggregate(cols[0]))
+        } else {
+            internal().yield(emptyPath(), aggregator.aggregate(cols))
+        }
+    }
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/aggregation/receivers/AggregateInternalDsl.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/aggregation/receivers/AggregateInternalDsl.kt
new file mode 100644
index 000000000..55cbcd80c
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/aggregation/receivers/AggregateInternalDsl.kt
@@ -0,0 +1,46 @@
+package org.jetbrains.kotlinx.dataframe.impl.aggregation.receivers
+
+import org.jetbrains.kotlinx.dataframe.AnyCol
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.Selector
+import org.jetbrains.kotlinx.dataframe.aggregation.AggregateBody
+import org.jetbrains.kotlinx.dataframe.aggregation.AggregateDsl
+import org.jetbrains.kotlinx.dataframe.aggregation.NamedValue
+import org.jetbrains.kotlinx.dataframe.columns.ColumnPath
+import kotlin.reflect.KType
+
+@PublishedApi
+internal interface AggregateInternalDsl<out T> {
+
+    val df: DataFrame<T>
+
+    val hasGroupingKeys: Boolean
+
+    fun yield(value: NamedValue): NamedValue
+
+    fun <R> yield(
+        path: ColumnPath,
+        value: R,
+        type: KType?,
+        default: R?,
+        guessType: Boolean,
+    ) = yield(NamedValue.create(path, value, type, default, guessType))
+
+    fun <R> yield(
+        path: ColumnPath,
+        value: R,
+        type: KType? = null,
+        default: R? = null,
+    ): NamedValue
+
+    fun pathForSingleColumn(column: AnyCol): ColumnPath
+}
+
+@PublishedApi
+internal fun <T> AggregateDsl<T>.internal(): AggregateInternalDsl<T> = this as AggregateInternalDsl<T>
+
+internal fun <T, R> AggregateBodyInternal<T, R>.public() = this as AggregateBody<T, R>
+
+internal fun <T, R> AggregateBody<T, R>.internal() = this as AggregateBodyInternal<T, R>
+
+internal typealias AggregateBodyInternal<T, R> = Selector<AggregateInternalDsl<T>, R>
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/aggregation/receivers/AggregatePivotDslImpl.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/aggregation/receivers/AggregatePivotDslImpl.kt
new file mode 100644
index 000000000..2d03adf56
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/aggregation/receivers/AggregatePivotDslImpl.kt
@@ -0,0 +1,33 @@
+package org.jetbrains.kotlinx.dataframe.impl.aggregation.receivers
+
+import org.jetbrains.kotlinx.dataframe.AnyCol
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.aggregation.AggregateDsl
+import org.jetbrains.kotlinx.dataframe.aggregation.NamedValue
+import org.jetbrains.kotlinx.dataframe.columns.ColumnPath
+import org.jetbrains.kotlinx.dataframe.impl.aggregation.AggregatableInternal
+import org.jetbrains.kotlinx.dataframe.impl.aggregation.internal
+import org.jetbrains.kotlinx.dataframe.impl.emptyPath
+import kotlin.reflect.KType
+
+internal class AggregatePivotDslImpl<T>(override val df: DataFrame<T>) :
+    AggregateDsl<T>(),
+    AggregateInternalDsl<T>,
+    DataFrame<T> by df,
+    AggregatableInternal<T> by df.internal() {
+
+    internal val values = mutableListOf<NamedValue>()
+
+    override fun yield(value: NamedValue) = value.also { values.add(it) }
+
+    override fun pathForSingleColumn(column: AnyCol) = emptyPath()
+
+    override fun <R> yield(
+        path: ColumnPath,
+        value: R,
+        type: KType?,
+        default: R?,
+    ) = yield(path, value, type, default, true)
+
+    override val hasGroupingKeys: Boolean get() = false
+}
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/concat.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/concat.kt
new file mode 100644
index 000000000..fbb86bd01
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/concat.kt
@@ -0,0 +1,114 @@
+package org.jetbrains.kotlinx.dataframe.impl.api
+
+import org.jetbrains.kotlinx.dataframe.DataColumn
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.api.asColumnGroup
+import org.jetbrains.kotlinx.dataframe.api.asDataColumn
+import org.jetbrains.kotlinx.dataframe.api.cast
+import org.jetbrains.kotlinx.dataframe.api.dataFrameOf
+import org.jetbrains.kotlinx.dataframe.api.emptyDataFrame
+import org.jetbrains.kotlinx.dataframe.api.isColumnGroup
+import org.jetbrains.kotlinx.dataframe.hasNulls
+import org.jetbrains.kotlinx.dataframe.impl.columns.guessColumnType
+import org.jetbrains.kotlinx.dataframe.impl.commonType
+import org.jetbrains.kotlinx.dataframe.impl.getListType
+import org.jetbrains.kotlinx.dataframe.impl.guessValueType
+import org.jetbrains.kotlinx.dataframe.nrow
+import kotlin.reflect.KType
+import kotlin.reflect.full.withNullability
+
+internal fun <T> concatImpl(name: String, columns: List<DataColumn<T>>): DataColumn<T> =
+    concatImpl(name, columns, columns.map { it.size() })
+
+internal fun <T> concatImpl(name: String, columns: List<DataColumn<T>?>, columnSizes: List<Int>): DataColumn<T> {
+    when (columns.size) {
+        0 -> return DataColumn.empty(name).cast()
+        1 -> return columns[0] ?: DataColumn.empty(name).cast()
+    }
+
+    if (columns.all { it == null || it.isColumnGroup() }) {
+        val frames = columns.mapIndexed { index, col ->
+            col?.asColumnGroup() ?: DataFrame.empty(columnSizes[index])
+        }
+        val merged = concatImpl(frames)
+        return DataColumn.createColumnGroup(name, merged).asDataColumn().cast()
+    } else {
+        var nulls = false
+        val types = mutableSetOf<KType>()
+        var listOfNullable = false
+        val defaultValue = columns.firstNotNullResult { it?.defaultValue() }
+        var hasList = false
+        val list = columns.flatMapIndexed { index, col ->
+            if (col != null) {
+                val type = col.type()
+                if (type.classifier == List::class) {
+                    val typeArgument = type.arguments[0].type
+                    if (typeArgument != null) {
+                        types.add(typeArgument)
+                        if (!listOfNullable) listOfNullable = typeArgument.isMarkedNullable
+                        hasList = true
+                    }
+                } else {
+                    types.add(type)
+                    if (!nulls) nulls = col.hasNulls
+                }
+                col.toList()
+            } else {
+                val nrow = columnSizes[index]
+                if (!nulls && nrow > 0 && defaultValue == null) {
+                    nulls = true
+                } else if (defaultValue != null) {
+                    types.add(
+                        guessValueType(sequenceOf(defaultValue)),
+                    )
+                }
+                List(nrow) { defaultValue }
+            }
+        }
+
+        val guessType = types.size > 1
+        val baseType = types.commonType()
+        val tartypeOf = if (guessType || !hasList) {
+            baseType.withNullability(nulls)
+        } else {
+            getListType(baseType.withNullability(listOfNullable))
+        }
+        return guessColumnType(
+            name = name,
+            values = list,
+            suggestedType = tartypeOf,
+            suggestedTypeIsUpperBound = guessType,
+            defaultValue = defaultValue,
+        ).cast()
+    }
+}
+
+internal fun <T> concatImpl(dataFrames: List<DataFrame<T>>): DataFrame<T> {
+    when (dataFrames.size) {
+        0 -> return emptyDataFrame()
+        1 -> return dataFrames[0]
+    }
+
+    // collect column names preserving original order
+    val columnNames = dataFrames
+        .fold(emptyList<String>()) { acc, df -> acc + (df.columnNames() - acc) }
+
+    val sizes = dataFrames.map { it.nrow }
+    val columns = columnNames.map { name ->
+        concatImpl(name, dataFrames.map { it.getColumnOrNull(name) }, sizes)
+    }
+    return if (columns.isEmpty()) {
+        // make sure the number of rows translate correctly if there are no columns
+        DataFrame.empty(nrow = sizes.sum())
+    } else {
+        dataFrameOf(columns)
+    }.cast()
+}
+
+private inline fun <T, R : Any> Iterable<T>.firstNotNullResult(transform: (T) -> R?): R? {
+    for (element in this) {
+        val result = transform(element)
+        if (result != null) return result
+    }
+    return null
+}
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/constructors.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/constructors.kt
new file mode 100644
index 000000000..ba166e3e2
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/constructors.kt
@@ -0,0 +1,18 @@
+package org.jetbrains.kotlinx.dataframe.impl.api
+
+internal fun <T> withValuesImpl(header: List<String>, values: List<T>): List<Pair<String, List<T>>> {
+    val ncol = header.size
+
+    require(header.isNotEmpty() && values.size.rem(ncol) == 0) {
+        "Number of values ${values.size} is not divisible by number of columns $ncol"
+    }
+
+    val nrow = values.size / ncol
+
+    return (0 until ncol).map { col ->
+        val colValues = (0 until nrow).map { row ->
+            values[row * ncol + col]
+        }
+        header[col] to colValues
+    }
+}
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/convert.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/convert.kt
new file mode 100644
index 000000000..8d4cf9430
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/convert.kt
@@ -0,0 +1,529 @@
+package org.jetbrains.kotlinx.dataframe.impl.api
+
+import kotlinx.datetime.Instant
+import kotlinx.datetime.LocalDate
+import kotlinx.datetime.LocalDateTime
+import kotlinx.datetime.LocalTime
+import kotlinx.datetime.TimeZone
+import kotlinx.datetime.atStartOfDayIn
+import kotlinx.datetime.atTime
+import kotlinx.datetime.toInstant
+import kotlinx.datetime.toJavaInstant
+import kotlinx.datetime.toJavaLocalDate
+import kotlinx.datetime.toJavaLocalDateTime
+import kotlinx.datetime.toJavaLocalTime
+import kotlinx.datetime.toKotlinInstant
+import kotlinx.datetime.toKotlinLocalDate
+import kotlinx.datetime.toKotlinLocalDateTime
+import kotlinx.datetime.toLocalDateTime
+import org.jetbrains.kotlinx.dataframe.AnyCol
+import org.jetbrains.kotlinx.dataframe.DataColumn
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.RowColumnExpression
+import org.jetbrains.kotlinx.dataframe.RowValueExpression
+import org.jetbrains.kotlinx.dataframe.api.Convert
+import org.jetbrains.kotlinx.dataframe.api.DataSchemaEnum
+import org.jetbrains.kotlinx.dataframe.api.Infer
+import org.jetbrains.kotlinx.dataframe.api.ParserOptions
+import org.jetbrains.kotlinx.dataframe.api.name
+import org.jetbrains.kotlinx.dataframe.api.to
+import org.jetbrains.kotlinx.dataframe.columns.values
+import org.jetbrains.kotlinx.dataframe.dataTypes.IFRAME
+import org.jetbrains.kotlinx.dataframe.dataTypes.IMG
+import org.jetbrains.kotlinx.dataframe.exceptions.CellConversionException
+import org.jetbrains.kotlinx.dataframe.exceptions.TypeConversionException
+import org.jetbrains.kotlinx.dataframe.exceptions.TypeConverterNotFoundException
+import org.jetbrains.kotlinx.dataframe.impl.columns.DataColumnInternal
+import org.jetbrains.kotlinx.dataframe.impl.columns.newColumn
+import org.jetbrains.kotlinx.dataframe.impl.createStarProjectedType
+import org.jetbrains.kotlinx.dataframe.path
+import org.jetbrains.kotlinx.dataframe.type
+import java.math.BigDecimal
+import java.net.URL
+import java.util.Locale
+import kotlin.math.roundToInt
+import kotlin.math.roundToLong
+import kotlin.reflect.KType
+import kotlin.reflect.full.isSubclassOf
+import kotlin.reflect.full.isSubtypeOf
+import kotlin.reflect.full.memberProperties
+import kotlin.reflect.full.primaryConstructor
+import kotlin.reflect.full.withNullability
+import kotlin.reflect.jvm.jvmErasure
+import java.time.Instant as JavaInstant
+import java.time.LocalDate as JavaLocalDate
+import java.time.LocalDateTime as JavaLocalDateTime
+import java.time.LocalTime as JavaLocalTime
+
+@PublishedApi
+internal fun <T, C, R> Convert<T, C>.withRowCellImpl(
+    type: KType,
+    infer: Infer,
+    rowConverter: RowValueExpression<T, C, R>,
+): DataFrame<T> = to { col -> df.newColumn(type, col.name, infer) { rowConverter(it, it[col]) } }
+
+@PublishedApi
+internal fun <T, C, R> Convert<T, C>.convertRowColumnImpl(
+    type: KType,
+    infer: Infer,
+    rowConverter: RowColumnExpression<T, C, R>,
+): DataFrame<T> = to { col -> df.newColumn(type, col.name, infer) { rowConverter(it, col) } }
+
+internal fun AnyCol.convertToTypeImpl(to: KType): AnyCol {
+    val from = type
+
+    val nullsAreAllowed = to.isMarkedNullable
+
+    var nullsFound = false
+
+    fun Any?.checkNulls() =
+        when {
+            this != null -> this
+
+            nullsAreAllowed -> {
+                nullsFound = true
+                null
+            }
+
+            else -> throw TypeConversionException(null, from, to, path)
+        }
+
+    fun applyConverter(converter: TypeConverter): AnyCol {
+        var currentRow = 0
+        try {
+            val values = values.mapIndexed { row, value ->
+                currentRow = row
+                value?.let { converter(value) }.checkNulls()
+            }
+            return DataColumn.createValueColumn(name, values, to.withNullability(nullsFound))
+        } catch (e: TypeConversionException) {
+            throw CellConversionException(e.value, e.from, e.to, path, currentRow, e)
+        }
+    }
+
+    fun convertPerCell(): AnyCol {
+        var currentRow = 0
+        try {
+            return when (from.classifier) {
+                Any::class, Comparable::class, Number::class, java.io.Serializable::class -> {
+                    // find converter for every value
+                    val values = values.mapIndexed { row, value ->
+                        currentRow = row
+                        value?.let {
+                            val clazz = it.javaClass.kotlin
+                            val type = clazz.createStarProjectedType(false)
+                            val converter = getConverter(type, to, ParserOptions(locale = Locale.getDefault()))
+                                ?: throw TypeConverterNotFoundException(from, to, path)
+                            converter(it)
+                        }.checkNulls()
+                    }
+                    DataColumn.createValueColumn(name, values, to.withNullability(nullsFound))
+                }
+
+                else -> throw TypeConverterNotFoundException(from, to, path)
+            }
+        } catch (e: TypeConversionException) {
+            throw CellConversionException(e.value, e.from, e.to, path, currentRow, e)
+        }
+    }
+
+    if (from == to) return this
+
+    // catch for ColumnGroup and FrameColumn since they don't have changeType,
+    // but user converters can still exist
+    if (from.isSubtypeOf(to)) {
+        try {
+            return (this as DataColumnInternal<*>).changeType(to.withNullability(hasNulls()))
+        } catch (_: UnsupportedOperationException) {
+            //
+        }
+    }
+
+    return when (val converter = getConverter(from, to, ParserOptions(locale = Locale.getDefault()))) {
+        null -> convertPerCell()
+        else -> applyConverter(converter)
+    }
+}
+
+internal val convertersCache = mutableMapOf<Triple<KType, KType, ParserOptions?>, TypeConverter?>()
+
+internal fun getConverter(from: KType, to: KType, options: ParserOptions? = null): TypeConverter? =
+    convertersCache.getOrPut(Triple(from, to, options)) { createConverter(from, to, options) }
+
+internal typealias TypeConverter = (Any) -> Any?
+
+internal fun Any.convertTo(type: KType): Any? {
+    val clazz = javaClass.kotlin
+    if (clazz.isSubclassOf(type.jvmErasure)) return this
+    val from = clazz.createStarProjectedType(false)
+    val converter = getConverter(from, type) ?: throw TypeConverterNotFoundException(from, type, null)
+    return converter(this)
+}
+
+internal inline fun <T> convert(crossinline converter: (T) -> Any?): TypeConverter = { converter(it as T) }
+
+private enum class DummyEnum
+
+internal fun createConverter(from: KType, to: KType, options: ParserOptions? = null): TypeConverter? {
+    if (from.arguments.isNotEmpty() || to.arguments.isNotEmpty()) return null
+    if (from.isMarkedNullable) {
+        val res = createConverter(from.withNullability(false), to, options) ?: return null
+        return { res(it) }
+    }
+    val fromClass = from.jvmErasure
+    val toClass = to.jvmErasure
+
+    if (fromClass == toClass) return { it }
+
+    if (toClass.isValue) {
+        val constructor =
+            toClass.primaryConstructor ?: error("Value type $toClass doesn't have primary constructor")
+        val underlyingType = constructor.parameters.single().type
+        val converter = getConverter(from, underlyingType)
+            ?: throw TypeConverterNotFoundException(from, underlyingType, null)
+        return convert<Any> {
+            val converted = converter(it)
+            if (converted == null && !underlyingType.isMarkedNullable) {
+                throw TypeConversionException(it, from, underlyingType, null)
+            }
+            constructor.call(converted)
+        }
+    }
+
+    return when {
+        fromClass == String::class -> {
+            val parser = Parsers[to.withNullability(false)]
+            when {
+                parser != null -> parser.toConverter(options)
+
+                // convert enums by name (or by `value` if they implement DataSchemaEnum)
+                toClass.isSubclassOf(Enum::class) -> convert<String> { string ->
+                    if (toClass.isSubclassOf(DataSchemaEnum::class)) {
+                        val enumValues = toClass.java.enumConstants as Array<out DataSchemaEnum>
+                        enumValues.firstOrNull { it.value == string }
+                            ?: java.lang.Enum.valueOf(toClass.java as Class<DummyEnum>, string)
+                    } else {
+                        java.lang.Enum.valueOf(toClass.java as Class<DummyEnum>, string)
+                    }
+                }
+
+                else -> null
+            }
+        }
+
+        toClass == String::class -> convert<Any> {
+            when {
+                // convert enums to String by `value` if they implement DataSchemaEnum
+                fromClass.isSubclassOf(DataSchemaEnum::class) ->
+                    (it as? DataSchemaEnum?)?.value ?: it.toString()
+
+                else -> it.toString()
+            }
+        }
+
+        fromClass.isValue -> {
+            val constructor =
+                fromClass.primaryConstructor ?: error("Value type $fromClass doesn't have primary constructor")
+            val constructorParameter = constructor.parameters.single()
+            val underlyingType = constructorParameter.type
+            val converter = getConverter(underlyingType, to)
+                ?: throw TypeConverterNotFoundException(underlyingType, to, null)
+            val property =
+                fromClass.memberProperties
+                    .single { it.name == constructorParameter.name } as kotlin.reflect.KProperty1<Any, *>
+            if (property.visibility != kotlin.reflect.KVisibility.PUBLIC) {
+                throw TypeConversionException(
+                    "Not public member property in primary constructor of value type",
+                    from,
+                    to,
+                    null,
+                )
+            }
+
+            convert<Any> {
+                property.get(it)?.let {
+                    converter(it)
+                }
+            }
+        }
+
+        else -> when (fromClass) {
+            Boolean::class -> when (toClass) {
+                Float::class -> convert<Boolean> { if (it) 1.0f else 0.0f }
+
+                Double::class -> convert<Boolean> { if (it) 1.0 else 0.0 }
+
+                Int::class -> convert<Boolean> { if (it) 1 else 0 }
+
+                Long::class -> convert<Boolean> { if (it) 1L else 0L }
+
+                Short::class -> convert<Boolean> {
+                    val one: Short = 1
+                    val zero: Short = 0
+                    if (it) one else zero
+                }
+
+                Byte::class -> convert<Boolean> {
+                    val one: Byte = 1
+                    val zero: Byte = 0
+                    if (it) one else zero
+                }
+
+                BigDecimal::class -> convert<Boolean> { if (it) BigDecimal.ONE else BigDecimal.ZERO }
+
+                else -> null
+            }
+
+            Number::class -> when (toClass) {
+                Double::class -> convert<Number> { it.toDouble() }
+                Int::class -> convert<Number> { it.toInt() }
+                Float::class -> convert<Number> { it.toFloat() }
+                Byte::class -> convert<Number> { it.toByte() }
+                Short::class -> convert<Number> { it.toShort() }
+                Long::class -> convert<Number> { it.toLong() }
+                Boolean::class -> convert<Number> { it.toDouble() != 0.0 }
+                else -> null
+            }
+
+            Int::class -> when (toClass) {
+                Double::class -> convert<Int> { it.toDouble() }
+
+                Float::class -> convert<Int> { it.toFloat() }
+
+                Byte::class -> convert<Int> { it.toByte() }
+
+                Short::class -> convert<Int> { it.toShort() }
+
+                Long::class -> convert<Int> { it.toLong() }
+
+                BigDecimal::class -> convert<Int> { it.toBigDecimal() }
+
+                Boolean::class -> convert<Int> { it != 0 }
+
+                LocalDateTime::class -> convert<Int> { it.toLong().toLocalDateTime(defaultTimeZone) }
+
+                LocalDate::class -> convert<Int> { it.toLong().toLocalDate(defaultTimeZone) }
+
+                LocalTime::class -> convert<Int> { it.toLong().toLocalTime(defaultTimeZone) }
+
+                Instant::class -> convert<Int> { Instant.fromEpochMilliseconds(it.toLong()) }
+
+                JavaLocalDateTime::class -> convert<Int> {
+                    it.toLong().toLocalDateTime(defaultTimeZone).toJavaLocalDateTime()
+                }
+
+                JavaLocalDate::class -> convert<Int> { it.toLong().toLocalDate(defaultTimeZone).toJavaLocalDate() }
+
+                JavaLocalTime::class -> convert<Int> { it.toLong().toLocalTime(defaultTimeZone).toJavaLocalTime() }
+
+                JavaInstant::class -> convert<Int> { JavaInstant.ofEpochMilli(it.toLong()) }
+
+                else -> null
+            }
+
+            Double::class -> when (toClass) {
+                Int::class -> convert<Double> { it.roundToInt() }
+                Float::class -> convert<Double> { it.toFloat() }
+                Long::class -> convert<Double> { it.roundToLong() }
+                Short::class -> convert<Double> { it.roundToInt().toShort() }
+                BigDecimal::class -> convert<Double> { it.toBigDecimal() }
+                Boolean::class -> convert<Double> { it != 0.0 }
+                else -> null
+            }
+
+            Long::class -> when (toClass) {
+                Double::class -> convert<Long> { it.toDouble() }
+
+                Float::class -> convert<Long> { it.toFloat() }
+
+                Byte::class -> convert<Long> { it.toByte() }
+
+                Short::class -> convert<Long> { it.toShort() }
+
+                Int::class -> convert<Long> { it.toInt() }
+
+                BigDecimal::class -> convert<Long> { it.toBigDecimal() }
+
+                Boolean::class -> convert<Long> { it != 0L }
+
+                LocalDateTime::class -> convert<Long> { it.toLocalDateTime(defaultTimeZone) }
+
+                LocalDate::class -> convert<Long> { it.toLocalDate(defaultTimeZone) }
+
+                Instant::class -> convert<Long> { Instant.fromEpochMilliseconds(it) }
+
+                JavaLocalDateTime::class -> convert<Long> {
+                    it.toLocalDateTime(defaultTimeZone).toJavaLocalDateTime()
+                }
+
+                JavaLocalDate::class -> convert<Long> { it.toLocalDate(defaultTimeZone).toJavaLocalDate() }
+
+                JavaLocalTime::class -> convert<Long> { it.toLocalTime(defaultTimeZone).toJavaLocalTime() }
+
+                JavaInstant::class -> convert<Long> { JavaInstant.ofEpochMilli(it) }
+
+                else -> null
+            }
+
+            Instant::class -> when (toClass) {
+                Long::class -> convert<Instant> { it.toEpochMilliseconds() }
+
+                LocalDateTime::class -> convert<Instant> { it.toLocalDateTime(defaultTimeZone) }
+
+                LocalDate::class -> convert<Instant> { it.toLocalDate(defaultTimeZone) }
+
+                LocalTime::class -> convert<Instant> { it.toLocalTime(defaultTimeZone) }
+
+                JavaLocalDateTime::class -> convert<Instant> {
+                    it.toLocalDateTime(defaultTimeZone).toJavaLocalDateTime()
+                }
+
+                JavaLocalDate::class -> convert<Instant> { it.toLocalDate(defaultTimeZone).toJavaLocalDate() }
+
+                JavaInstant::class -> convert<Instant> { it.toJavaInstant() }
+
+                JavaLocalTime::class -> convert<Instant> { it.toLocalTime(defaultTimeZone).toJavaLocalTime() }
+
+                else -> null
+            }
+
+            JavaInstant::class -> when (toClass) {
+                Long::class -> convert<JavaInstant> { it.toEpochMilli() }
+
+                LocalDateTime::class -> convert<JavaInstant> {
+                    it.toKotlinInstant().toLocalDateTime(defaultTimeZone)
+                }
+
+                LocalDate::class -> convert<JavaInstant> { it.toKotlinInstant().toLocalDate(defaultTimeZone) }
+
+                LocalTime::class -> convert<JavaInstant> { it.toKotlinInstant().toLocalTime(defaultTimeZone) }
+
+                Instant::class -> convert<JavaInstant> { it.toKotlinInstant() }
+
+                JavaLocalDateTime::class -> convert<JavaInstant> {
+                    it.toKotlinInstant().toLocalDateTime(defaultTimeZone).toJavaLocalDateTime()
+                }
+
+                JavaLocalDate::class -> convert<JavaInstant> {
+                    it.toKotlinInstant().toLocalDate(defaultTimeZone).toJavaLocalDate()
+                }
+
+                JavaLocalTime::class -> convert<JavaInstant> {
+                    it.toKotlinInstant().toLocalTime(defaultTimeZone).toJavaLocalTime()
+                }
+
+                else -> null
+            }
+
+            Float::class -> when (toClass) {
+                Double::class -> convert<Float> { it.toDouble() }
+                Long::class -> convert<Float> { it.roundToLong() }
+                Int::class -> convert<Float> { it.roundToInt() }
+                Short::class -> convert<Float> { it.roundToInt().toShort() }
+                BigDecimal::class -> convert<Float> { it.toBigDecimal() }
+                Boolean::class -> convert<Float> { it != 0.0F }
+                else -> null
+            }
+
+            BigDecimal::class -> when (toClass) {
+                Double::class -> convert<BigDecimal> { it.toDouble() }
+                Int::class -> convert<BigDecimal> { it.toInt() }
+                Float::class -> convert<BigDecimal> { it.toFloat() }
+                Long::class -> convert<BigDecimal> { it.toLong() }
+                Boolean::class -> convert<BigDecimal> { it != BigDecimal.ZERO }
+                else -> null
+            }
+
+            LocalDateTime::class -> when (toClass) {
+                LocalDate::class -> convert<LocalDateTime> { it.date }
+                LocalTime::class -> convert<LocalDateTime> { it.time }
+                Instant::class -> convert<LocalDateTime> { it.toInstant(defaultTimeZone) }
+                Long::class -> convert<LocalDateTime> { it.toInstant(defaultTimeZone).toEpochMilliseconds() }
+                JavaLocalDateTime::class -> convert<LocalDateTime> { it.toJavaLocalDateTime() }
+                JavaLocalDate::class -> convert<LocalDateTime> { it.date.toJavaLocalDate() }
+                JavaLocalTime::class -> convert<LocalDateTime> { it.toJavaLocalDateTime().toLocalTime() }
+                JavaInstant::class -> convert<LocalDateTime> { it.toInstant(defaultTimeZone).toJavaInstant() }
+                else -> null
+            }
+
+            JavaLocalDateTime::class -> when (toClass) {
+                LocalDate::class -> convert<JavaLocalDateTime> { it.toKotlinLocalDateTime().date }
+
+                LocalTime::class -> convert<JavaLocalDateTime> { it.toKotlinLocalDateTime().time }
+
+                LocalDateTime::class -> convert<JavaLocalDateTime> { it.toKotlinLocalDateTime() }
+
+                Instant::class -> convert<JavaLocalDateTime> {
+                    it.toKotlinLocalDateTime().toInstant(defaultTimeZone)
+                }
+
+                Long::class -> convert<JavaLocalDateTime> {
+                    it.toKotlinLocalDateTime().toInstant(defaultTimeZone).toEpochMilliseconds()
+                }
+
+                JavaLocalDate::class -> convert<JavaLocalDateTime> { it.toLocalDate() }
+
+                JavaLocalTime::class -> convert<JavaLocalDateTime> { it.toLocalTime() }
+
+                JavaInstant::class -> convert<JavaLocalDateTime> {
+                    it.toKotlinLocalDateTime().toInstant(defaultTimeZone).toJavaInstant()
+                }
+
+                else -> null
+            }
+
+            LocalDate::class -> when (toClass) {
+                LocalDateTime::class -> convert<LocalDate> { it.atTime(0, 0) }
+                Instant::class -> convert<LocalDate> { it.atStartOfDayIn(defaultTimeZone) }
+                Long::class -> convert<LocalDate> { it.atStartOfDayIn(defaultTimeZone).toEpochMilliseconds() }
+                JavaLocalDate::class -> convert<LocalDate> { it.toJavaLocalDate() }
+                JavaLocalDateTime::class -> convert<LocalDate> { it.atTime(0, 0).toJavaLocalDateTime() }
+                JavaInstant::class -> convert<LocalDate> { it.atStartOfDayIn(defaultTimeZone).toJavaInstant() }
+                else -> null
+            }
+
+            JavaLocalDate::class -> when (toClass) {
+                LocalDate::class -> convert<JavaLocalDate> { it.toKotlinLocalDate() }
+
+                LocalDateTime::class -> convert<JavaLocalDate> { it.atTime(0, 0).toKotlinLocalDateTime() }
+
+                Instant::class -> convert<JavaLocalDate> {
+                    it.toKotlinLocalDate().atStartOfDayIn(defaultTimeZone)
+                }
+
+                Long::class -> convert<JavaLocalDate> {
+                    it.toKotlinLocalDate().atStartOfDayIn(defaultTimeZone).toEpochMilliseconds()
+                }
+
+                JavaLocalDateTime::class -> convert<JavaLocalDate> { it.atStartOfDay() }
+
+                JavaInstant::class -> convert<JavaLocalDate> {
+                    it.toKotlinLocalDate().atStartOfDayIn(defaultTimeZone).toJavaInstant()
+                }
+
+                else -> null
+            }
+
+            URL::class -> when (toClass) {
+                IMG::class -> convert<URL> { IMG(it.toString()) }
+                IFRAME::class -> convert<URL> { IFRAME(it.toString()) }
+                else -> null
+            }
+
+            else -> null
+        }
+    }
+}
+
+internal fun Long.toLocalDateTime(zone: TimeZone = defaultTimeZone) =
+    Instant.fromEpochMilliseconds(this).toLocalDateTime(zone)
+
+internal fun Long.toLocalDate(zone: TimeZone = defaultTimeZone) = toLocalDateTime(zone).date
+
+internal fun Long.toLocalTime(zone: TimeZone = defaultTimeZone) = toLocalDateTime(zone).time
+
+internal fun Instant.toLocalDate(zone: TimeZone = defaultTimeZone) = toLocalDateTime(zone).date
+
+internal fun Instant.toLocalTime(zone: TimeZone = defaultTimeZone) = toLocalDateTime(zone).time
+
+internal val defaultTimeZone = TimeZone.currentSystemDefault()
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/convertTo.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/convertTo.kt
new file mode 100644
index 000000000..48c2864df
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/convertTo.kt
@@ -0,0 +1,321 @@
+package org.jetbrains.kotlinx.dataframe.impl.api
+
+import io.github.oshai.kotlinlogging.KotlinLogging
+import org.jetbrains.kotlinx.dataframe.AnyFrame
+import org.jetbrains.kotlinx.dataframe.AnyRow
+import org.jetbrains.kotlinx.dataframe.ColumnsSelector
+import org.jetbrains.kotlinx.dataframe.DataColumn
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.DataRow
+import org.jetbrains.kotlinx.dataframe.RowExpression
+import org.jetbrains.kotlinx.dataframe.api.ConvertSchemaDsl
+import org.jetbrains.kotlinx.dataframe.api.ConverterScope
+import org.jetbrains.kotlinx.dataframe.api.ExcessiveColumns
+import org.jetbrains.kotlinx.dataframe.api.Infer
+import org.jetbrains.kotlinx.dataframe.api.add
+import org.jetbrains.kotlinx.dataframe.api.all
+import org.jetbrains.kotlinx.dataframe.api.allNulls
+import org.jetbrains.kotlinx.dataframe.api.concat
+import org.jetbrains.kotlinx.dataframe.api.convertTo
+import org.jetbrains.kotlinx.dataframe.api.emptyDataFrame
+import org.jetbrains.kotlinx.dataframe.api.isColumnGroup
+import org.jetbrains.kotlinx.dataframe.api.isEmpty
+import org.jetbrains.kotlinx.dataframe.api.map
+import org.jetbrains.kotlinx.dataframe.api.name
+import org.jetbrains.kotlinx.dataframe.api.toDataFrame
+import org.jetbrains.kotlinx.dataframe.api.update
+import org.jetbrains.kotlinx.dataframe.api.with
+import org.jetbrains.kotlinx.dataframe.codeGen.MarkersExtractor
+import org.jetbrains.kotlinx.dataframe.columns.ColumnGroup
+import org.jetbrains.kotlinx.dataframe.columns.ColumnKind
+import org.jetbrains.kotlinx.dataframe.columns.ColumnPath
+import org.jetbrains.kotlinx.dataframe.columns.FrameColumn
+import org.jetbrains.kotlinx.dataframe.columns.UnresolvedColumnsPolicy
+import org.jetbrains.kotlinx.dataframe.columns.toColumnSet
+import org.jetbrains.kotlinx.dataframe.exceptions.ExcessiveColumnsException
+import org.jetbrains.kotlinx.dataframe.exceptions.TypeConversionException
+import org.jetbrains.kotlinx.dataframe.impl.emptyPath
+import org.jetbrains.kotlinx.dataframe.impl.getColumnPaths
+import org.jetbrains.kotlinx.dataframe.impl.schema.createEmptyDataFrame
+import org.jetbrains.kotlinx.dataframe.impl.schema.createNullFilledColumn
+import org.jetbrains.kotlinx.dataframe.impl.schema.extractSchema
+import org.jetbrains.kotlinx.dataframe.impl.schema.render
+import org.jetbrains.kotlinx.dataframe.kind
+import org.jetbrains.kotlinx.dataframe.schema.ColumnSchema
+import org.jetbrains.kotlinx.dataframe.schema.DataFrameSchema
+import org.jetbrains.kotlinx.dataframe.size
+import kotlin.reflect.KType
+import kotlin.reflect.full.withNullability
+import kotlin.reflect.jvm.jvmErasure
+
+private val logger = KotlinLogging.logger {}
+
+private open class Converter(val transform: ConverterScope.(Any?) -> Any?, val skipNulls: Boolean)
+
+private class Filler(val columns: ColumnsSelector<*, *>, val expr: RowExpression<*, *>)
+
+internal interface ConvertSchemaDslInternal<T> : ConvertSchemaDsl<T> {
+    public fun <C> fill(columns: ColumnsSelector<*, C>, expr: RowExpression<*, C>)
+}
+
+private class ConvertSchemaDslImpl<T> : ConvertSchemaDslInternal<T> {
+    private val converters: MutableMap<Pair<KType, KType>, Converter> = mutableMapOf<Pair<KType, KType>, Converter>()
+
+    val fillers = mutableListOf<Filler>()
+
+    private val flexibleConverters: MutableMap<(KType, ColumnSchema) -> Boolean, Converter> = mutableMapOf()
+
+    @Suppress("UNCHECKED_CAST")
+    override fun <A, B> convert(from: KType, to: KType, converter: (A) -> B) {
+        converters[from.withNullability(false) to to.withNullability(false)] =
+            Converter({ converter(it as A) }, !from.isMarkedNullable)
+    }
+
+    override fun <C> fill(columns: ColumnsSelector<*, C>, expr: RowExpression<*, C>) {
+        fillers.add(Filler(columns, expr))
+    }
+
+    override fun convertIf(condition: (KType, ColumnSchema) -> Boolean, converter: ConverterScope.(Any?) -> Any?) {
+        flexibleConverters[condition] = Converter(converter, false)
+    }
+
+    /**
+     * Attempts to find a converter for the given types. First it tries to find an exact match,
+     * then it tries to find a flexible match where the first one will be used.
+     */
+    fun getConverter(fromType: KType, toSchema: ColumnSchema): Converter? =
+        converters[fromType.withNullability(false) to toSchema.type.withNullability(false)]
+            ?: flexibleConverters
+                .entries
+                .firstOrNull { (predicate, _) ->
+                    predicate(fromType, toSchema)
+                }?.value
+}
+
+@PublishedApi
+internal fun AnyFrame.convertToImpl(
+    type: KType,
+    allowConversion: Boolean,
+    excessiveColumns: ExcessiveColumns,
+    body: ConvertSchemaDsl<Any>.() -> Unit = {},
+): AnyFrame {
+    val dsl = ConvertSchemaDslImpl<Any>()
+    dsl.body()
+
+    val missingPaths = mutableSetOf<ColumnPath>()
+
+    fun AnyFrame.convertToSchema(schema: DataFrameSchema, path: ColumnPath): AnyFrame {
+        // if current frame is empty
+        if (this.isEmpty()) {
+            return schema.createEmptyDataFrame()
+        }
+
+        val visited = mutableSetOf<String>()
+        val newColumns = columns().mapNotNull { originalColumn ->
+            val targetSchema = schema.columns[originalColumn.name()]
+            if (targetSchema == null) {
+                when (excessiveColumns) {
+                    ExcessiveColumns.Fail -> throw ExcessiveColumnsException(listOf(originalColumn.name))
+                    ExcessiveColumns.Keep -> originalColumn
+                    ExcessiveColumns.Remove -> null
+                }
+            } else {
+                visited.add(originalColumn.name())
+                val currentSchema = originalColumn.extractSchema()
+                when {
+                    targetSchema == currentSchema -> originalColumn
+
+                    !allowConversion -> {
+                        val originalSchema = mapOf(originalColumn.name to currentSchema)
+                            .render(0, StringBuilder(), "\t")
+
+                        val targetSchema = mapOf(originalColumn.name to targetSchema)
+                            .render(0, StringBuilder(), "\t")
+
+                        throw IllegalArgumentException(
+                            "Column has schema:\n $originalSchema\n that differs from target schema:\n $targetSchema",
+                        )
+                    }
+
+                    else -> {
+                        val columnPath = path + originalColumn.name
+
+                        // try to perform any user-specified conversions first
+                        val from = originalColumn.type()
+                        val to = targetSchema.type
+                        val converter = dsl.getConverter(from, targetSchema)
+
+                        val convertedColumn = if (converter != null) {
+                            val nullsAllowed = to.isMarkedNullable
+                            originalColumn.map(to, Infer.Nulls) {
+                                val result =
+                                    if (it != null || !converter.skipNulls) {
+                                        converter.transform(ConverterScope(from, targetSchema), it)
+                                    } else {
+                                        it
+                                    }
+
+                                if (!nullsAllowed && result == null) {
+                                    throw TypeConversionException(
+                                        value = it,
+                                        from = from,
+                                        to = to,
+                                        column = originalColumn.path(),
+                                    )
+                                }
+
+                                result
+                            }
+                        } else {
+                            null
+                        }
+
+                        when (targetSchema.kind) {
+                            ColumnKind.Value ->
+                                convertedColumn ?: originalColumn.convertTo(to)
+
+                            ColumnKind.Group -> {
+                                val column = when {
+                                    convertedColumn != null -> convertedColumn
+
+                                    // Value column of DataRows (if it ever occurs) can be converted to a group column
+                                    originalColumn.kind == ColumnKind.Value &&
+                                        originalColumn.all { it is DataRow<*> } ->
+                                        DataColumn.createColumnGroup(
+                                            name = originalColumn.name,
+                                            df = originalColumn.values()
+                                                .let { it as Iterable<DataRow<*>> }
+                                                .toDataFrame(),
+                                        ) as DataColumn<*>
+
+                                    // Value column of nulls can be converted to an empty group column
+                                    originalColumn.kind == ColumnKind.Value && originalColumn.allNulls() ->
+                                        DataColumn.createColumnGroup(
+                                            name = originalColumn.name,
+                                            df = DataFrame.empty(nrow = originalColumn.size),
+                                        ) as DataColumn<*>
+
+                                    else -> originalColumn
+                                }
+                                require(column.isColumnGroup()) {
+                                    "Column `${column.name}` is ${column.kind} and can not be converted to `ColumnGroup`"
+                                }
+                                DataColumn.createColumnGroup(
+                                    name = column.name(),
+                                    df = column.convertToSchema(
+                                        schema = (targetSchema as ColumnSchema.Group).schema,
+                                        path = columnPath,
+                                    ),
+                                )
+                            }
+
+                            ColumnKind.Frame -> {
+                                val column = convertedColumn ?: originalColumn
+                                val frameSchema = (targetSchema as ColumnSchema.Frame).schema
+
+                                val frames = when (column.kind) {
+                                    ColumnKind.Frame ->
+                                        (column as FrameColumn<*>).values()
+
+                                    ColumnKind.Value -> {
+                                        require(
+                                            column.all {
+                                                it == null ||
+                                                    it is AnyFrame ||
+                                                    (it is List<*> && it.all { it is AnyRow? })
+                                            },
+                                        ) {
+                                            "Column `${column.name}` is ValueColumn and contains objects that can not be converted into `DataFrame`"
+                                        }
+                                        column.values().map {
+                                            when (it) {
+                                                null -> emptyDataFrame()
+                                                is AnyFrame -> it
+                                                else -> (it as List<AnyRow?>).concat()
+                                            }
+                                        }
+                                    }
+
+                                    ColumnKind.Group -> {
+                                        (column as ColumnGroup<*>).values().map { it.toDataFrame() }
+                                    }
+                                }
+
+                                val convertedFrames = frames.map { it.convertToSchema(frameSchema, columnPath) }
+
+                                DataColumn.createFrameColumn(
+                                    name = column.name(),
+                                    groups = convertedFrames,
+                                    schema = lazy { frameSchema },
+                                )
+                            }
+                        }
+                    }
+                }
+            }
+        }.toMutableList()
+
+        // when the target is nullable but the source does not contain a column,
+        // fill it in with nulls / empty dataframes
+        val size = this.size.nrow
+        schema.columns.forEach { (name, targetColumn) ->
+            if (name !in visited) {
+                try {
+                    newColumns += targetColumn.createNullFilledColumn(name, size)
+                } catch (e: IllegalStateException) {
+                    logger.debug(e) { "" }
+                    // if this could not be done automatically, they need to be filled manually
+                    missingPaths.add(path + name)
+                }
+            }
+        }
+        return newColumns.toDataFrame()
+    }
+
+    val clazz = type.jvmErasure
+    val marker = MarkersExtractor.get(clazz)
+    var result = convertToSchema(marker.schema, emptyPath())
+
+    /*
+     * Here we handle all registered fillers of the user.
+     * Fillers are registered in the DSL like:
+     * ```kt
+     * df.convertTo<Target> {
+     *   fill { col1 and col2 }.with { something }
+     *   fill { col3 }.with { somethingElse }
+     * }
+     * ```
+     * Users can use this to fill up any column that was missing during the conversion.
+     * They can also fill up and thus overwrite any existing column here.
+     */
+    dsl.fillers.forEach { filler ->
+        // get all paths from the `fill { col1 and col2 }` part
+        val paths = result.getColumnPaths(UnresolvedColumnsPolicy.Create, filler.columns).toSet()
+
+        // split the paths into those that are already in the df and those that are missing
+        val (newPaths, existingPaths) = paths.partition { it in missingPaths }
+
+        // first fill cols that are already in the df using the `with {}` part of the dsl
+        result = result.update { existingPaths.toColumnSet() }.with { filler.expr(this, this) }
+
+        // then create any missing ones by filling using the `with {}` part of the dsl
+        result = newPaths.fold(result) { df, newPath ->
+            df.add(newPath, Infer.Type) { filler.expr(this, this) }
+        }
+
+        // remove the paths that are now filled
+        missingPaths -= paths
+    }
+
+    // Inform the user which target columns could not be created in the conversion
+    // The user will need to supply extra information for these, like `fill {}` them.
+    if (missingPaths.isNotEmpty()) {
+        throw IllegalArgumentException(
+            "The following columns were not found in DataFrame: ${
+                missingPaths.map { it.joinToString() }
+            }, and their type was not nullable. Use `fill` to initialize these columns",
+        )
+    }
+
+    return result
+}
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/corr.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/corr.kt
new file mode 100644
index 000000000..5796de097
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/corr.kt
@@ -0,0 +1,79 @@
+package org.jetbrains.kotlinx.dataframe.impl.api
+
+import org.jetbrains.kotlinx.dataframe.ColumnsSelector
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.api.Corr
+import org.jetbrains.kotlinx.dataframe.api.cast
+import org.jetbrains.kotlinx.dataframe.api.castToNotNullable
+import org.jetbrains.kotlinx.dataframe.api.convertToDouble
+import org.jetbrains.kotlinx.dataframe.api.dataFrameOf
+import org.jetbrains.kotlinx.dataframe.api.getColumnsWithPaths
+import org.jetbrains.kotlinx.dataframe.api.isColumnGroup
+import org.jetbrains.kotlinx.dataframe.api.isSuitableForCorr
+import org.jetbrains.kotlinx.dataframe.api.toValueColumn
+import org.jetbrains.kotlinx.dataframe.columns.ColumnPath
+import org.jetbrains.kotlinx.dataframe.columns.ColumnWithPath
+import org.jetbrains.kotlinx.dataframe.math.varianceAndMean
+import org.jetbrains.kotlinx.dataframe.nrow
+import kotlin.math.sqrt
+
+internal fun <T, C, R> Corr<T, C>.corrImpl(otherColumns: ColumnsSelector<T, R>): DataFrame<T> {
+    val len = df.nrow
+
+    fun <P> List<ColumnWithPath<P>>.unpackColumnGroups() =
+        flatMap {
+            // extract nested number columns from ColumnGroups
+            if (it.isColumnGroup()) {
+                val groupPath = it.path
+                df.getColumnsWithPaths { groupPath.colsAtAnyDepth { it.isSuitableForCorr() } }.map { it.cast() }
+            } else {
+                listOf(it)
+            }
+        }
+
+    var cols1 = df.getColumnsWithPaths(columns)
+        .filter { it.isColumnGroup() || it.isSuitableForCorr() }
+
+    val cols2 = df.getColumnsWithPaths(otherColumns)
+        .filter { it.isColumnGroup() || it.isSuitableForCorr() }
+        .unpackColumnGroups()
+
+    val indexColumnName = if (cols1.size == 1 && cols1[0].isColumnGroup()) cols1[0].name else "column"
+    cols1 = cols1.unpackColumnGroups()
+
+    val index = cols1.map { it.name }.toValueColumn(indexColumnName)
+
+    val cols = cols1.associateTo(mutableMapOf()) { it.path to it.data.convertToDouble().castToNotNullable() }
+    cols2.forEach {
+        if (!cols.containsKey(it.path)) {
+            cols[it.path] = it.data.convertToDouble().castToNotNullable()
+        }
+    }
+
+    val stdMeans = cols.mapValues {
+        it.value.toList().varianceAndMean()
+    }
+
+    val cache = mutableMapOf<Pair<ColumnPath, ColumnPath>, Double>()
+
+    val newColumns = cols2.map { c2 ->
+        val values = cols1.map { c1 ->
+            val cachedValue = cache[c2.path to c1.path]
+            if (cachedValue != null) {
+                cachedValue
+            } else {
+                val s1 = stdMeans[c1.path]!!
+                val s2 = stdMeans[c2.path]!!
+                val v1 = cols[c1.path]!!
+                val v2 = cols[c2.path]!!
+                val res = (0 until len)
+                    .sumOf { (v1[it] - s1.mean) * (v2[it] - s2.mean) } / sqrt(s1.variance * s2.variance)
+                cache[c1.path to c2.path] = res
+                res
+            }
+        }
+        values.toValueColumn(c2.name)
+    }
+
+    return dataFrameOf(listOf(index) + newColumns).cast()
+}
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/describe.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/describe.kt
new file mode 100644
index 000000000..dad18f490
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/describe.kt
@@ -0,0 +1,96 @@
+package org.jetbrains.kotlinx.dataframe.impl.api
+
+import org.jetbrains.kotlinx.dataframe.AnyCol
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.api.ColumnDescription
+import org.jetbrains.kotlinx.dataframe.api.add
+import org.jetbrains.kotlinx.dataframe.api.after
+import org.jetbrains.kotlinx.dataframe.api.asColumnGroup
+import org.jetbrains.kotlinx.dataframe.api.asComparable
+import org.jetbrains.kotlinx.dataframe.api.asNumbers
+import org.jetbrains.kotlinx.dataframe.api.cast
+import org.jetbrains.kotlinx.dataframe.api.concat
+import org.jetbrains.kotlinx.dataframe.api.isComparable
+import org.jetbrains.kotlinx.dataframe.api.isNumber
+import org.jetbrains.kotlinx.dataframe.api.maxOrNull
+import org.jetbrains.kotlinx.dataframe.api.mean
+import org.jetbrains.kotlinx.dataframe.api.medianOrNull
+import org.jetbrains.kotlinx.dataframe.api.minOrNull
+import org.jetbrains.kotlinx.dataframe.api.move
+import org.jetbrains.kotlinx.dataframe.api.name
+import org.jetbrains.kotlinx.dataframe.api.std
+import org.jetbrains.kotlinx.dataframe.api.toDataFrame
+import org.jetbrains.kotlinx.dataframe.columns.ColumnKind
+import org.jetbrains.kotlinx.dataframe.columns.size
+import org.jetbrains.kotlinx.dataframe.columns.values
+import org.jetbrains.kotlinx.dataframe.impl.columns.addPath
+import org.jetbrains.kotlinx.dataframe.impl.columns.asAnyFrameColumn
+import org.jetbrains.kotlinx.dataframe.impl.renderType
+import org.jetbrains.kotlinx.dataframe.index
+import org.jetbrains.kotlinx.dataframe.kind
+import org.jetbrains.kotlinx.dataframe.type
+
+internal fun describeImpl(cols: List<AnyCol>): DataFrame<ColumnDescription> {
+    fun List<AnyCol>.collectAll(atAnyDepth: Boolean): List<AnyCol> =
+        flatMap { col ->
+            when (col.kind) {
+                ColumnKind.Frame ->
+                    col.asAnyFrameColumn()
+                        .concat()
+                        .columns()
+                        .map { it.addPath(col.path() + it.name) }
+                        .collectAll(true)
+
+                ColumnKind.Group ->
+                    if (atAnyDepth) {
+                        col.asColumnGroup()
+                            .columns()
+                            .map { it.addPath(col.path() + it.name) }
+                            .collectAll(true)
+                    } else {
+                        listOf(col)
+                    }
+
+                ColumnKind.Value -> listOf(col)
+            }
+        }
+
+    val all = cols.collectAll(false)
+
+    val hasNumeric = all.any { it.isNumber() }
+    val hasComparable = all.any { it.isComparable() }
+    val hasLongPaths = all.any { it.path().size > 1 }
+    var df = all.toDataFrame {
+        ColumnDescription::name from { it.name() }
+        if (hasLongPaths) {
+            ColumnDescription::path from { it.path() }
+        }
+        ColumnDescription::type from { renderType(it.type) }
+        ColumnDescription::count from { it.size }
+        ColumnDescription::unique from { it.countDistinct() }
+        ColumnDescription::nulls from { it.values.count { it == null } }
+        ColumnDescription::top from inferType {
+            it.values.filterNotNull()
+                .groupBy { it }.maxByOrNull { it.value.size }
+                ?.key
+        }
+        if (hasNumeric) {
+            ColumnDescription::mean from { if (it.isNumber()) it.asNumbers().mean() else null }
+            ColumnDescription::std from { if (it.isNumber()) it.asNumbers().std() else null }
+        }
+        if (hasComparable) {
+            ColumnDescription::min from inferType { if (it.isComparable()) it.asComparable().minOrNull() else null }
+            ColumnDescription::median from inferType {
+                if (it.isComparable()) it.asComparable().medianOrNull() else null
+            }
+            ColumnDescription::max from inferType { if (it.isComparable()) it.asComparable().maxOrNull() else null }
+        }
+    }
+    df = df.add(ColumnDescription::freq) {
+        val top = it[ColumnDescription::top]
+        val data = all[index]
+        data.values.count { it == top }
+    }.move(ColumnDescription::freq).after(ColumnDescription::top)
+
+    return df.cast()
+}
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/duplicate.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/duplicate.kt
new file mode 100644
index 000000000..159c02ca3
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/duplicate.kt
@@ -0,0 +1,99 @@
+package org.jetbrains.kotlinx.dataframe.impl.api
+
+import org.jetbrains.kotlinx.dataframe.AnyFrame
+import org.jetbrains.kotlinx.dataframe.DataColumn
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.DataRow
+import org.jetbrains.kotlinx.dataframe.api.asDataColumn
+import org.jetbrains.kotlinx.dataframe.api.asDataFrame
+import org.jetbrains.kotlinx.dataframe.api.cast
+import org.jetbrains.kotlinx.dataframe.api.forEachIndexed
+import org.jetbrains.kotlinx.dataframe.api.isFrameColumn
+import org.jetbrains.kotlinx.dataframe.api.name
+import org.jetbrains.kotlinx.dataframe.api.toDataFrame
+import org.jetbrains.kotlinx.dataframe.columns.ColumnGroup
+import org.jetbrains.kotlinx.dataframe.impl.owner
+import org.jetbrains.kotlinx.dataframe.index
+import org.jetbrains.kotlinx.dataframe.type
+import kotlin.reflect.full.withNullability
+
+internal fun <T> DataFrame<T>.duplicateRowsImpl(n: Int): DataFrame<T> =
+    columns()
+        .map { it.duplicateValuesImpl(n) }
+        .toDataFrame()
+        .cast()
+
+internal fun <T> DataColumn<T>.duplicateValuesImpl(n: Int): DataColumn<T> {
+    require(n > 0)
+    return when (this) {
+        is ColumnGroup<*> ->
+            DataColumn
+                .createColumnGroup(
+                    name = name,
+                    df = asDataFrame().duplicateRowsImpl(n),
+                ).asDataColumn()
+
+        else -> {
+            val list = List(size() * n) { get(it / n) }
+            if (isFrameColumn()) {
+                DataColumn.createFrameColumn(name, list as List<AnyFrame>)
+            } else {
+                DataColumn.createValueColumn(name, list, type, defaultValue = defaultValue())
+            }
+        }
+    }.cast()
+}
+
+internal fun <T> DataColumn<T>.duplicateValuesImpl(n: Int, indicesSorted: Iterable<Int>): DataColumn<T> =
+    when (this) {
+        is ColumnGroup<*> ->
+            DataColumn.createColumnGroup(
+                name = name,
+                df = asDataFrame().duplicateRowsImpl(n, indicesSorted),
+            ).asDataColumn()
+
+        else -> {
+            val list = mutableListOf<Any?>()
+            val iterator = indicesSorted.iterator()
+            var next = if (iterator.hasNext()) iterator.next() else -1
+            forEachIndexed { i, value ->
+                if (i == next) {
+                    repeat(n) { list.add(value) }
+                    next = if (iterator.hasNext()) iterator.next() else -1
+                } else {
+                    list.add(value)
+                }
+            }
+            if (isFrameColumn()) {
+                DataColumn.createFrameColumn(name, list as List<AnyFrame>)
+            } else {
+                DataColumn.createValueColumn(name, list, type, defaultValue = defaultValue())
+            }
+        }
+    }.cast()
+
+internal fun <T> DataFrame<T>.duplicateRowsImpl(n: Int, indicesSorted: Iterable<Int>): DataFrame<T> =
+    columns()
+        .map { it.duplicateValuesImpl(n, indicesSorted) }
+        .toDataFrame()
+        .cast()
+
+internal fun <T> DataRow<T>.duplicateImpl(n: Int): DataFrame<T> =
+    owner.columns().map { col ->
+        when (col) {
+            is ColumnGroup<*> -> DataColumn.createColumnGroup(col.name, col[index].duplicateImpl(n))
+
+            else -> {
+                val value = col[index]
+                if (value is AnyFrame) {
+                    DataColumn.createFrameColumn(col.name, List(n) { value })
+                } else {
+                    DataColumn.createValueColumn(
+                        col.name,
+                        List(n) { value },
+                        col.type.withNullability(value == null),
+                    )
+                }
+            }
+        }
+    }.toDataFrame().cast()
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/explode.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/explode.kt
new file mode 100644
index 000000000..25dc1530f
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/explode.kt
@@ -0,0 +1,118 @@
+package org.jetbrains.kotlinx.dataframe.impl.api
+
+import org.jetbrains.kotlinx.dataframe.AnyBaseCol
+import org.jetbrains.kotlinx.dataframe.AnyCol
+import org.jetbrains.kotlinx.dataframe.AnyFrame
+import org.jetbrains.kotlinx.dataframe.ColumnsSelector
+import org.jetbrains.kotlinx.dataframe.DataColumn
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.api.appendNulls
+import org.jetbrains.kotlinx.dataframe.api.asSequence
+import org.jetbrains.kotlinx.dataframe.api.cast
+import org.jetbrains.kotlinx.dataframe.api.concat
+import org.jetbrains.kotlinx.dataframe.api.dataFrameOf
+import org.jetbrains.kotlinx.dataframe.api.getColumn
+import org.jetbrains.kotlinx.dataframe.api.getColumnsWithPaths
+import org.jetbrains.kotlinx.dataframe.api.isFrameColumn
+import org.jetbrains.kotlinx.dataframe.api.name
+import org.jetbrains.kotlinx.dataframe.api.pathOf
+import org.jetbrains.kotlinx.dataframe.api.toDataFrame
+import org.jetbrains.kotlinx.dataframe.columns.ColumnGroup
+import org.jetbrains.kotlinx.dataframe.columns.ColumnPath
+import org.jetbrains.kotlinx.dataframe.columns.FrameColumn
+import org.jetbrains.kotlinx.dataframe.columns.ValueColumn
+import org.jetbrains.kotlinx.dataframe.columns.size
+import org.jetbrains.kotlinx.dataframe.columns.values
+import org.jetbrains.kotlinx.dataframe.impl.columns.asAnyFrameColumn
+import org.jetbrains.kotlinx.dataframe.impl.createDataCollector
+import org.jetbrains.kotlinx.dataframe.indices
+import org.jetbrains.kotlinx.dataframe.nrow
+import org.jetbrains.kotlinx.dataframe.type
+
+internal fun AnyCol.explodeImpl(): AnyCol = dataFrameOf(this).explodeImpl(true) { all() }.getColumn(0)
+
+internal fun <T> DataFrame<T>.explodeImpl(dropEmpty: Boolean = true, columns: ColumnsSelector<T, *>): DataFrame<T> {
+    val columns = getColumnsWithPaths(columns)
+    if (columns.isEmpty()) return this
+
+    val rowExpandSizes = indices.map { row ->
+        columns.maxOf {
+            val n = when (val value = it.data[row]) {
+                is AnyFrame -> value.nrow
+                is List<*> -> value.size
+                else -> 1
+            }
+            if (!dropEmpty && n == 0) 1 else n
+        }
+    }
+
+    val outputRowsCount = rowExpandSizes.sum()
+
+    fun splitIntoRows(df: AnyFrame, data: Map<ColumnPath, AnyCol>): AnyFrame {
+        val newColumns: List<AnyBaseCol> = df.columns().map { srcCol ->
+
+            val dstCol = data[pathOf(srcCol.name)]
+            if (srcCol is ColumnGroup<*>) { // go to nested columns recursively
+                val newData = data.mapNotNull {
+                    if (it.key.isNotEmpty() && it.key[0] == srcCol.name) {
+                        it.key.drop(1) to it.value
+                    } else {
+                        null
+                    }
+                }.toMap()
+                val newDf = splitIntoRows(srcCol, newData)
+                DataColumn.createColumnGroup(srcCol.name, newDf)
+            } else if (dstCol != null) { // values in current column will be split
+                when (dstCol) {
+                    is FrameColumn<*> -> {
+                        val newDf = dstCol.values.mapIndexed { row, frame ->
+                            val expectedSize = rowExpandSizes[row]
+                            assert(frame.nrow <= expectedSize)
+                            frame.appendNulls(expectedSize - frame.nrow)
+                        }.concat()
+
+                        DataColumn.createColumnGroup(dstCol.name, newDf)
+                    }
+
+                    is ValueColumn<*> -> {
+                        val collector = createDataCollector(outputRowsCount)
+                        dstCol.asSequence().forEachIndexed { rowIndex, value ->
+                            val list = valueToList(value, splitStrings = false)
+                            val expectedSize = rowExpandSizes[rowIndex]
+                            list.forEach { collector.add(it) }
+                            repeat(expectedSize - list.size) {
+                                collector.add(null)
+                            }
+                        }
+                        collector.toColumn(dstCol.name)
+                    }
+
+                    else -> error("")
+                }
+            } else { // values in current column will be duplicated
+                val collector = createDataCollector<Any?>(outputRowsCount, srcCol.type)
+                for (row in 0 until srcCol.size) {
+                    val expandSize = rowExpandSizes[row]
+                    if (expandSize > 0) {
+                        val value = srcCol[row]
+                        repeat(expandSize) {
+                            collector.add(value)
+                        }
+                    }
+                }
+                if (srcCol.isFrameColumn()) {
+                    DataColumn.createFrameColumn(
+                        name = srcCol.name,
+                        groups = collector.values as List<AnyFrame>,
+                        schema = srcCol.asAnyFrameColumn().schema, // keep original schema
+                    )
+                } else {
+                    collector.toColumn(srcCol.name)
+                }
+            }
+        }
+        return newColumns.toDataFrame()
+    }
+
+    return splitIntoRows(this, columns.associate { it.path to it.data }).cast()
+}
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/format.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/format.kt
new file mode 100644
index 000000000..07e6f6803
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/format.kt
@@ -0,0 +1,73 @@
+package org.jetbrains.kotlinx.dataframe.impl.api
+
+import org.jetbrains.kotlinx.dataframe.api.CellAttributes
+import org.jetbrains.kotlinx.dataframe.api.FormatClause
+import org.jetbrains.kotlinx.dataframe.api.FormattedFrame
+import org.jetbrains.kotlinx.dataframe.api.FormattingDSL
+import org.jetbrains.kotlinx.dataframe.api.RGBColor
+import org.jetbrains.kotlinx.dataframe.api.RowColFormatter
+import org.jetbrains.kotlinx.dataframe.api.and
+import org.jetbrains.kotlinx.dataframe.api.cast
+import org.jetbrains.kotlinx.dataframe.api.getColumnsWithPaths
+import org.jetbrains.kotlinx.dataframe.api.name
+import org.jetbrains.kotlinx.dataframe.columns.depth
+
+internal class SingleAttribute(val key: String, val value: String) : CellAttributes {
+    override fun attributes() = listOf(key to value)
+}
+
+internal class MergedAttributes(private val attributes: List<CellAttributes>) : CellAttributes {
+    override fun attributes() = attributes.flatMap { it.attributes() }.toMap().toList()
+}
+
+internal fun encRgb(r: Short, g: Short, b: Short): String = "#${encHex(r)}${encHex(g)}${encHex(b)}"
+
+internal fun encHex(v: Short): String = "${(v / 16).toString(16)}${(v % 16).toString(16)}"
+
+internal fun RGBColor.encode() = encRgb(r, g, b)
+
+internal fun componentWise(color1: RGBColor, color2: RGBColor, f: (Short, Short) -> Short) =
+    RGBColor(
+        f(color1.r, color2.r),
+        f(color1.g, color2.g),
+        f(color1.b, color2.b),
+    )
+
+internal fun linearGradient(
+    x: Double,
+    minValue: Double,
+    minColor: RGBColor,
+    maxValue: Double,
+    maxColor: RGBColor,
+): RGBColor {
+    if (x < minValue) return minColor
+    if (x > maxValue) return maxColor
+    val t = (x - minValue) / (maxValue - minValue)
+    return componentWise(minColor, maxColor) { cmin, cmax ->
+        (cmin + t * (cmax - cmin)).toInt().toShort()
+    }
+}
+
+internal fun <T, C> FormatClause<T, C>.formatImpl(formatter: RowColFormatter<T, C>): FormattedFrame<T> {
+    val columns =
+        if (columns != null) {
+            df.getColumnsWithPaths(columns)
+                .mapNotNull { if (it.depth == 0) it.name else null }
+                .toSet()
+        } else {
+            null
+        }
+    return FormattedFrame(df) { row, col ->
+        val oldAttributes = oldFormatter?.invoke(FormattingDSL, row, col.cast())
+        if (columns == null || columns.contains(col.name())) {
+            val value = row[col] as C
+            if (filter == null || filter(row, value)) {
+                oldAttributes and formatter(FormattingDSL, row.cast(), col.cast())
+            } else {
+                oldAttributes
+            }
+        } else {
+            oldAttributes
+        }
+    }
+}
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/gather.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/gather.kt
new file mode 100644
index 000000000..de8926180
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/gather.kt
@@ -0,0 +1,124 @@
+package org.jetbrains.kotlinx.dataframe.impl.api
+
+import org.jetbrains.kotlinx.dataframe.DataColumn
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.api.Gather
+import org.jetbrains.kotlinx.dataframe.api.add
+import org.jetbrains.kotlinx.dataframe.api.cast
+import org.jetbrains.kotlinx.dataframe.api.column
+import org.jetbrains.kotlinx.dataframe.api.convert
+import org.jetbrains.kotlinx.dataframe.api.explode
+import org.jetbrains.kotlinx.dataframe.api.into
+import org.jetbrains.kotlinx.dataframe.api.isEmpty
+import org.jetbrains.kotlinx.dataframe.api.map
+import org.jetbrains.kotlinx.dataframe.api.named
+import org.jetbrains.kotlinx.dataframe.api.replace
+import org.jetbrains.kotlinx.dataframe.api.split
+import org.jetbrains.kotlinx.dataframe.api.to
+import org.jetbrains.kotlinx.dataframe.api.with
+
+internal fun <T, C, K, R> Gather<T, C, K, R>.gatherImpl(
+    namesTo: String? = null,
+    valuesTo: String? = null,
+): DataFrame<T> {
+    require(namesTo != null || valuesTo != null)
+
+    val removed = df.removeImpl(columns = columns)
+
+    val columnsToGather = removed.removedColumns.map { it.data.column as DataColumn<C> }
+
+    val keys = columnsToGather.map { keyTransform(it.name()) }
+
+    val keysColumn = namesTo?.let { column<List<K>>(it) }
+    val valuesColumn = valuesTo?.let { column<List<Any?>>(it) }
+
+    var df = removed.df
+
+    val filter = filter
+    val valueTransform = valueTransform
+
+    // optimization when no filter is applied
+    if (filter == null) {
+        // add key and value columns
+        if (keysColumn != null) {
+            df = df.add(keysColumn) { keys }
+        }
+
+        if (valuesColumn != null) {
+            df = df.add(valuesColumn) { row ->
+                columnsToGather.map { col ->
+                    val value = col[row]
+                    if (valueTransform != null) {
+                        when {
+                            explode && value is List<*> -> (value as List<C>).map(valueTransform)
+                            else -> valueTransform(value)
+                        }
+                    } else {
+                        value
+                    }
+                }
+            }
+        }
+
+        // explode keys and values
+        df = when {
+            keysColumn != null && valuesColumn != null -> df.explode(keysColumn, valuesColumn)
+            else -> df.explode(keysColumn ?: valuesColumn!!)
+        }
+
+        // explode values in lists
+        if (explode && valuesColumn != null) {
+            df = df.explode(valuesColumn)
+        }
+    } else {
+        val nameAndValue = column<List<Pair<K, Any?>>>("nameAndValue")
+        df = df.add(nameAndValue) { row ->
+            columnsToGather.mapIndexedNotNull { colIndex, col ->
+                val value = col[row]
+                when {
+                    explode && value is List<*> -> {
+                        val filtered = (value as List<C>).filter { filter(it) }
+                        val transformed = valueTransform?.let { filtered.map(it) } ?: filtered
+                        keys[colIndex] to transformed
+                    }
+
+                    filter(value) -> {
+                        val transformed = valueTransform?.invoke(value) ?: value
+                        keys[colIndex] to transformed
+                    }
+
+                    else -> null
+                }
+            }
+        }
+
+        df = df.explode { nameAndValue }
+
+        if (df.isEmpty()) return df
+
+        val nameAndValuePairs = nameAndValue.cast<Pair<*, *>>()
+
+        when {
+            keysColumn != null && valuesColumn != null -> {
+                df = df
+                    .split { nameAndValuePairs }
+                    .into(keysColumn.name(), valuesColumn.name())
+                    .explode(valuesColumn)
+            }
+
+            keysColumn != null -> {
+                df = df.replace { nameAndValuePairs }.with { it.map { it.first } named keysColumn.name() }
+            }
+
+            valuesColumn != null -> {
+                df = df.replace { nameAndValuePairs }.with { it.map { it.second } named valuesColumn.name() }
+            }
+        }
+    }
+
+    if (keysColumn != null && keyType != null) {
+        df = df.convert(keysColumn.name()).to(keyType)
+    }
+
+    return df
+}
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/groupBy.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/groupBy.kt
new file mode 100644
index 000000000..8656eecf9
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/groupBy.kt
@@ -0,0 +1,69 @@
+package org.jetbrains.kotlinx.dataframe.impl.api
+
+import org.jetbrains.kotlinx.dataframe.ColumnsSelector
+import org.jetbrains.kotlinx.dataframe.DataColumn
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.DataRow
+import org.jetbrains.kotlinx.dataframe.api.GroupBy
+import org.jetbrains.kotlinx.dataframe.api.GroupedDataRow
+import org.jetbrains.kotlinx.dataframe.api.cast
+import org.jetbrains.kotlinx.dataframe.api.getColumnsWithPaths
+import org.jetbrains.kotlinx.dataframe.api.getRows
+import org.jetbrains.kotlinx.dataframe.api.indices
+import org.jetbrains.kotlinx.dataframe.api.pathOf
+import org.jetbrains.kotlinx.dataframe.columns.FrameColumn
+import org.jetbrains.kotlinx.dataframe.impl.GroupByImpl
+import org.jetbrains.kotlinx.dataframe.impl.nameGenerator
+
+internal class GroupedDataRowImpl<T, G>(private val row: DataRow<T>, private val frameCol: FrameColumn<G>) :
+    GroupedDataRow<T, G>,
+    DataRow<T> by row {
+
+    override fun group() = frameCol[row.index()]
+}
+
+internal fun <T> DataFrame<T>.groupByImpl(moveToTop: Boolean, columns: ColumnsSelector<T, *>): GroupBy<T, T> {
+    val nameGenerator = nameGenerator(GroupBy.groupedColumnAccessor.name())
+    var keyColumns = getColumnsWithPaths(columns)
+    if (!moveToTop) {
+        keyColumns = keyColumns.map {
+            val currentName = it.name()
+            val uniqueName = nameGenerator.addUnique(currentName)
+            if (uniqueName != currentName) {
+                it.rename(uniqueName)
+            } else {
+                it
+            }
+        }
+    }
+    val groups = indices()
+        .map { index -> keyColumns.map { it[index] } to index }
+        .groupBy({ it.first }) { it.second }
+        .toList()
+
+    val keyIndices = groups.map { it.second[0] }
+
+    val keyColumnsToInsert = keyColumns.map {
+        val column = it[keyIndices]
+        val path = if (moveToTop) pathOf(it.name()) else it.path()
+        ColumnToInsert(path, column, null)
+    }
+
+    val keyColumnsDf = dataFrameOf(keyColumnsToInsert).cast<T>()
+
+    val permutation = groups.flatMap { it.second }
+    val sorted = getRows(permutation)
+
+    var lastIndex = 0
+    val startIndices = groups.asSequence().map {
+        val start = lastIndex
+        lastIndex += it.second.size
+        start
+    }
+
+    val groupedColumnName = keyColumnsDf.nameGenerator().addUnique(GroupBy.groupedColumnAccessor.name())
+    val groupedColumn = DataColumn.createFrameColumn(groupedColumnName, sorted, startIndices.asIterable())
+
+    val df = keyColumnsDf + groupedColumn
+    return GroupByImpl(df, groupedColumn, columns)
+}
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/implode.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/implode.kt
new file mode 100644
index 000000000..988f7bc3b
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/implode.kt
@@ -0,0 +1,43 @@
+package org.jetbrains.kotlinx.dataframe.impl.api
+
+import org.jetbrains.kotlinx.dataframe.AnyFrame
+import org.jetbrains.kotlinx.dataframe.ColumnsSelector
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.api.asColumnGroup
+import org.jetbrains.kotlinx.dataframe.api.concat
+import org.jetbrains.kotlinx.dataframe.api.dropNA
+import org.jetbrains.kotlinx.dataframe.api.groupBy
+import org.jetbrains.kotlinx.dataframe.api.map
+import org.jetbrains.kotlinx.dataframe.api.replace
+import org.jetbrains.kotlinx.dataframe.api.with
+import org.jetbrains.kotlinx.dataframe.columns.ColumnKind
+import org.jetbrains.kotlinx.dataframe.impl.columns.asAnyFrameColumn
+import org.jetbrains.kotlinx.dataframe.impl.columns.extractDataFrame
+import org.jetbrains.kotlinx.dataframe.impl.getListType
+import kotlin.reflect.typeOf
+
+internal fun <T, C> DataFrame<T>.implodeImpl(dropNA: Boolean = false, columns: ColumnsSelector<T, C>): DataFrame<T> =
+    groupBy { allExcept(columns) }.updateGroups {
+        replace(columns).with { column ->
+            val (value, type) = when (column.kind()) {
+                ColumnKind.Value -> (if (dropNA) column.dropNA() else column).toList() to getListType(column.type())
+                ColumnKind.Group -> column.asColumnGroup().extractDataFrame() to typeOf<AnyFrame>()
+                ColumnKind.Frame -> column.asAnyFrameColumn().concat() to typeOf<List<AnyFrame>>()
+            }
+            var first = true
+            column.map(type) {
+                if (first) {
+                    first = false
+                    value
+                } else {
+                    // these rows will not be taken into account,
+                    // but we cannot leave them empty, as `map` creates a full column
+                    when (column.kind()) {
+                        ColumnKind.Value -> emptyList<Any?>()
+                        ColumnKind.Group -> DataFrame.empty()
+                        ColumnKind.Frame -> emptyList<AnyFrame>()
+                    }
+                }
+            }
+        }[0..0] // takes only the first row
+    }.concat()
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/join.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/join.kt
new file mode 100644
index 000000000..efcb6d568
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/join.kt
@@ -0,0 +1,262 @@
+package org.jetbrains.kotlinx.dataframe.impl.api
+
+import org.jetbrains.kotlinx.dataframe.AnyFrame
+import org.jetbrains.kotlinx.dataframe.DataColumn
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.api.ColumnMatch
+import org.jetbrains.kotlinx.dataframe.api.JoinColumnsSelector
+import org.jetbrains.kotlinx.dataframe.api.JoinDsl
+import org.jetbrains.kotlinx.dataframe.api.JoinType
+import org.jetbrains.kotlinx.dataframe.api.allowLeftNulls
+import org.jetbrains.kotlinx.dataframe.api.allowRightNulls
+import org.jetbrains.kotlinx.dataframe.api.getColumnsWithPaths
+import org.jetbrains.kotlinx.dataframe.api.indices
+import org.jetbrains.kotlinx.dataframe.api.isColumnGroup
+import org.jetbrains.kotlinx.dataframe.api.toColumnAccessor
+import org.jetbrains.kotlinx.dataframe.api.toDataFrameFromPairs
+import org.jetbrains.kotlinx.dataframe.columns.ColumnKind
+import org.jetbrains.kotlinx.dataframe.columns.ColumnReference
+import org.jetbrains.kotlinx.dataframe.columns.ColumnWithPath
+import org.jetbrains.kotlinx.dataframe.columns.ColumnsResolver
+import org.jetbrains.kotlinx.dataframe.columns.UnresolvedColumnsPolicy
+import org.jetbrains.kotlinx.dataframe.columns.toColumnSet
+import org.jetbrains.kotlinx.dataframe.impl.DataFrameReceiver
+import org.jetbrains.kotlinx.dataframe.impl.columns.ColumnsList
+import org.jetbrains.kotlinx.dataframe.indices
+import org.jetbrains.kotlinx.dataframe.kind
+import org.jetbrains.kotlinx.dataframe.nrow
+import org.jetbrains.kotlinx.dataframe.type
+import kotlin.reflect.full.withNullability
+
+internal fun <A, B> defaultJoinColumns(left: DataFrame<A>, right: DataFrame<B>): JoinColumnsSelector<A, B> =
+    {
+        left.columnNames().intersect(right.columnNames().toSet())
+            .map { it.toColumnAccessor() }
+            .let { ColumnsList(it) }
+    }
+
+internal fun <T> defaultJoinColumns(dataFrames: Iterable<DataFrame<T>>): JoinColumnsSelector<T, T> =
+    {
+        dataFrames.map { it.columnNames() }
+            .fold<List<String>, Set<String>?>(null) { set, names ->
+                set?.intersect(names.toSet()) ?: names.toSet()
+            }.orEmpty()
+            .map { it.toColumnAccessor() }
+            .let { ColumnsList(it) }
+    }
+
+internal fun <C> ColumnsResolver<C>.extractJoinColumns(): List<ColumnMatch<C>> =
+    when (this) {
+        is ColumnsList -> columns.flatMap { it.extractJoinColumns() }
+        is ColumnReference<C> -> listOf(ColumnMatch(this, path().toColumnAccessor() as ColumnReference<C>))
+        is ColumnMatch -> listOf(this)
+        else -> throw Exception()
+    }
+
+internal fun <A, B> DataFrame<A>.getColumns(
+    other: DataFrame<B>,
+    selector: JoinColumnsSelector<A, B>,
+): List<ColumnMatch<Any?>> {
+    val receiver = object : DataFrameReceiver<A>(this, UnresolvedColumnsPolicy.Fail), JoinDsl<A, B> {
+        override val right: DataFrame<B> = DataFrameReceiver(other, UnresolvedColumnsPolicy.Fail)
+    }
+    val columns = selector(receiver, this)
+    return columns.extractJoinColumns()
+}
+
+internal fun <A, B> DataFrame<A>.joinImpl(
+    other: DataFrame<B>,
+    joinType: JoinType = JoinType.Inner,
+    addNewColumns: Boolean = true,
+    selector: JoinColumnsSelector<A, B>?,
+): DataFrame<A> {
+    val joinColumns = getColumns(other, selector ?: defaultJoinColumns(this, other))
+
+    val leftJoinColumns = getColumnsWithPaths { joinColumns.map { it.left }.toColumnSet() }
+    val rightJoinColumns = other.getColumnsWithPaths { joinColumns.map { it.right }.toColumnSet() }
+
+    require(leftJoinColumns.size == rightJoinColumns.size)
+
+    // replace all ColumnGroups in join with nested columns, matching by column path
+    val allLeftJoinColumns = mutableListOf<ColumnWithPath<*>>()
+    val allRightJoinColumns = mutableListOf<ColumnWithPath<*>>()
+
+    leftJoinColumns.indices.forEach { i ->
+        val leftCol = leftJoinColumns[i]
+        val rightCol = rightJoinColumns[i]
+        if (leftCol.isColumnGroup() && rightCol.isColumnGroup()) {
+            val leftColumns = getColumnsWithPaths {
+                leftCol.colsAtAnyDepth { !it.isColumnGroup() }
+            }
+            val rightColumns = other.getColumnsWithPaths {
+                rightCol.colsAtAnyDepth { !it.isColumnGroup() }
+            }
+
+            val leftPrefixLength = leftCol.path.size
+            val rightPrefixLength = rightCol.path.size
+            val leftMap = leftColumns.associateBy { it.path.drop(leftPrefixLength) }.toMutableMap()
+
+            rightColumns.forEach { right ->
+                val relativePath = right.path.drop(rightPrefixLength)
+                val left = leftMap[relativePath]
+                if (left == null) {
+                    require(selector == null) {
+                        "Unable to perform join by column groups `${leftCol.name}` to `${rightCol.name}, because `$relativePath` was not found under `${leftCol.name}` in left DataFrame"
+                    }
+                } else {
+                    allLeftJoinColumns.add(left)
+                    allRightJoinColumns.add(right)
+                    leftMap.remove(relativePath)
+                }
+            }
+            require(leftMap.isEmpty() || selector == null) {
+                "Unable to perform join by column groups `${leftCol.name}` to `${rightCol.name}, because `${leftMap.values.first()}` was not found under `${rightCol.name}` in right DataFrame"
+            }
+        } else {
+            allLeftJoinColumns.add(leftCol)
+            allRightJoinColumns.add(rightCol)
+        }
+    }
+
+    // compute left to right column path mappings
+    val pathMapping = allLeftJoinColumns
+        .mapIndexed { colNumber, leftCol ->
+            leftCol.path to allRightJoinColumns[colNumber].path
+        }.toMap()
+
+    // compute pairs of join key to row index from right data frame
+    val rightJoinKeyToIndex = other
+        .indices()
+        .map { index -> allRightJoinColumns.map { it.data[index] } to index }
+
+    // group row indices by key from right data frame
+    val groupedRight = when (joinType) {
+        JoinType.Exclude -> rightJoinKeyToIndex.associate { it.first to emptyList<Int>() }
+        else -> rightJoinKeyToIndex.groupBy({ it.first }) { it.second }
+    }
+
+    var outputRowsCount = 0
+
+    // for every row index from left data frame compute a list of matched indices from right data frame
+    val leftToRightMapping = indices.map { leftIndex ->
+        val leftKey = allLeftJoinColumns.map { it.data[leftIndex] }
+        val rightIndices = groupedRight[leftKey]
+        outputRowsCount += rightIndices?.size ?: if (joinType.allowRightNulls) 1 else 0
+        rightIndices
+    }
+
+    // for every row index in right data frame store a flag indicating whether this row was matched by some row in left data frame
+    val rightMatched = BooleanArray(other.nrow) { false }
+
+    // number of rows in right data frame that were not matched by any row in left data frame. Used for correct allocation of an output array
+    var rightUnmatchedCount = other.nrow
+
+    // compute matched indices from right data frame and number of rows in output data frame
+    if (joinType.allowLeftNulls) {
+        leftToRightMapping.forEach { rightIndices ->
+            rightIndices?.forEach { i ->
+                if (!rightMatched[i]) {
+                    rightUnmatchedCount--
+                    rightMatched[i] = true
+                }
+            }
+        }
+        outputRowsCount += rightUnmatchedCount
+    }
+
+    val leftColumns = getColumnsWithPaths { colsAtAnyDepth { !it.isColumnGroup() } }
+
+    val rightJoinColumnPaths = allRightJoinColumns.associate { it.path to it.data }
+
+    val newRightColumns =
+        if (addNewColumns) {
+            other.getColumnsWithPaths {
+                colsAtAnyDepth {
+                    !it.isColumnGroup() && !rightJoinColumnPaths.contains(it.path)
+                }
+            }
+        } else {
+            emptyList()
+        }
+
+    // for every column index from the left dataframe store matching column from the right dataframe
+    val leftToRightColumns = leftColumns.map { rightJoinColumnPaths[pathMapping[it.path()]] }
+
+    val leftColumnsCount = leftColumns.size
+    val newRightColumnsCount = newRightColumns.size
+    val outputColumnsCount = leftColumnsCount + newRightColumnsCount
+
+    val outputData = List<Array<Any?>>(outputColumnsCount) { arrayOfNulls(outputRowsCount) }
+    val hasNulls = BooleanArray(outputColumnsCount) { false }
+
+    var row = 0
+
+    leftToRightMapping.forEachIndexed { leftRow, rightRows ->
+        if (rightRows == null) {
+            if (joinType.allowRightNulls) {
+                for (col in 0 until leftColumnsCount) {
+                    val leftColumn = leftColumns[col].data
+                    outputData[col][row] = leftColumn[leftRow].also { if (it == null) hasNulls[col] = true }
+                }
+                for (col in 0 until newRightColumnsCount) {
+                    outputData[leftColumnsCount + col][row] = null
+                    hasNulls[leftColumnsCount + col] = true
+                }
+                row++
+            }
+        } else {
+            for (rightRow in rightRows) {
+                for (col in 0 until leftColumnsCount) {
+                    val leftColumn = leftColumns[col].data
+                    outputData[col][row] = leftColumn[leftRow].also { if (it == null) hasNulls[col] = true }
+                }
+                for (col in 0 until newRightColumnsCount) {
+                    val rightColumn = newRightColumns[col].data
+                    outputData[leftColumnsCount + col][row] =
+                        rightColumn[rightRow].also { if (it == null) hasNulls[leftColumnsCount + col] = true }
+                }
+                row++
+            }
+        }
+    }
+
+    if (joinType.allowLeftNulls) {
+        for (rightRow in rightMatched.indices) {
+            if (!rightMatched[rightRow]) {
+                for (col in 0 until leftColumnsCount) {
+                    val rightColumn = leftToRightColumns[col]
+                    outputData[col][row] = rightColumn?.get(rightRow).also { if (it == null) hasNulls[col] = true }
+                }
+                for (col in 0 until newRightColumnsCount) {
+                    val rightColumn = newRightColumns[col].data
+                    outputData[leftColumnsCount + col][row] =
+                        rightColumn[rightRow].also { if (it == null) hasNulls[leftColumnsCount + col] = true }
+                }
+                row++
+            }
+        }
+    }
+
+    val columns = outputData.mapIndexed { columnIndex, columnValues ->
+        val srcColumn = if (columnIndex < leftColumnsCount) {
+            leftColumns[columnIndex]
+        } else {
+            newRightColumns[columnIndex - leftColumnsCount]
+        }
+        val hasNulls = hasNulls[columnIndex]
+        val newColumn = when (srcColumn.kind) {
+            ColumnKind.Value -> DataColumn.createValueColumn(
+                name = srcColumn.name,
+                values = columnValues.asList(),
+                type = srcColumn.type.withNullability(hasNulls),
+            )
+
+            ColumnKind.Frame -> DataColumn.createFrameColumn(srcColumn.name, columnValues.asList() as List<AnyFrame>)
+
+            ColumnKind.Group -> error("Unexpected ColumnGroup at path ${srcColumn.path}")
+        }
+        srcColumn.path to newColumn
+    }
+
+    return columns.toDataFrameFromPairs()
+}
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/joinWith.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/joinWith.kt
new file mode 100644
index 000000000..182ac6747
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/joinWith.kt
@@ -0,0 +1,99 @@
+package org.jetbrains.kotlinx.dataframe.impl.api
+
+import org.jetbrains.kotlinx.dataframe.DataColumn
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.DataRow
+import org.jetbrains.kotlinx.dataframe.api.JoinExpression
+import org.jetbrains.kotlinx.dataframe.api.JoinType
+import org.jetbrains.kotlinx.dataframe.api.JoinedDataRow
+import org.jetbrains.kotlinx.dataframe.api.allowLeftNulls
+import org.jetbrains.kotlinx.dataframe.api.allowRightNulls
+import org.jetbrains.kotlinx.dataframe.api.cast
+import org.jetbrains.kotlinx.dataframe.api.count
+import org.jetbrains.kotlinx.dataframe.api.indices
+import org.jetbrains.kotlinx.dataframe.api.toDataFrame
+import org.jetbrains.kotlinx.dataframe.impl.ColumnNameGenerator
+import org.jetbrains.kotlinx.dataframe.impl.DataRowImpl
+
+internal class JoinedDataRowImpl<A, B>(
+    leftOwner: DataFrame<A>,
+    val index: Int,
+    rightOwner: DataFrame<B>,
+    index1: Int,
+) : DataRowImpl<A>(index, leftOwner),
+    JoinedDataRow<A, B> {
+    override val right: DataRow<B> = DataRowImpl(index1, rightOwner)
+}
+
+internal fun <A, B> DataFrame<A>.joinWithImpl(
+    right: DataFrame<B>,
+    type: JoinType = JoinType.Inner,
+    addNewColumns: Boolean,
+    joinExpression: JoinExpression<A, B>,
+): DataFrame<A> {
+    val generator = ColumnNameGenerator(columnNames())
+    if (addNewColumns) {
+        right.columnNames().forEach { generator.addUnique(it) }
+    }
+    val rightColumnsCount = if (addNewColumns) right.columnsCount() else 0
+    val outputData = List(columnsCount() + rightColumnsCount) { mutableListOf<Any?>() }
+    val rightMatched = BooleanArray(right.count()) { false }
+    for (l in indices()) {
+        var leftMatched = false
+        for (r in right.indices()) {
+            val joined = JoinedDataRowImpl(this, l, right, r)
+            val matched = joinExpression(joined, joined)
+            if (matched && type == JoinType.Exclude) {
+                leftMatched = true
+                break
+            }
+            if (matched) {
+                rightMatched[r] = true
+                leftMatched = true
+                val left = get(l).values()
+                for (col in left.indices) {
+                    outputData[col].add(left[col])
+                }
+                if (addNewColumns) {
+                    val offset = left.size
+                    val row = right.get(r).values()
+                    for (col in row.indices) {
+                        outputData[col + offset].add(row[col])
+                    }
+                }
+            }
+        }
+        if (!leftMatched && type.allowRightNulls) {
+            val left = get(l).values()
+            for (col in left.indices) {
+                outputData[col].add(left[col])
+            }
+            if (addNewColumns) {
+                for (col in left.size..outputData.lastIndex) {
+                    outputData[col].add(null)
+                }
+            }
+        }
+    }
+
+    if (type.allowLeftNulls) {
+        rightMatched.forEachIndexed { row, matched ->
+            if (!matched) {
+                repeat(columnsCount()) { col ->
+                    outputData[col].add(null)
+                }
+                val offset = columnsCount()
+                val rowData = right[row].values()
+                for (col in rowData.indices) {
+                    outputData[offset + col].add(rowData[col])
+                }
+            }
+        }
+    }
+
+    val df: DataFrame<*> = outputData.mapIndexed { index, values ->
+        DataColumn.createWithTypeInference(generator.names[index], values)
+    }.toDataFrame()
+
+    return df.cast()
+}
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/map.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/map.kt
new file mode 100644
index 000000000..5bf67f97f
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/map.kt
@@ -0,0 +1,21 @@
+package org.jetbrains.kotlinx.dataframe.impl.api
+
+import org.jetbrains.kotlinx.dataframe.DataColumn
+import org.jetbrains.kotlinx.dataframe.api.cast
+import org.jetbrains.kotlinx.dataframe.api.name
+import org.jetbrains.kotlinx.dataframe.columns.size
+import org.jetbrains.kotlinx.dataframe.columns.values
+import org.jetbrains.kotlinx.dataframe.impl.createDataCollector
+
+@PublishedApi
+internal fun <T, R> DataColumn<T?>.mapNotNullValues(transform: (T) -> R): DataColumn<R?> {
+    val collector = createDataCollector(size)
+    values.forEach {
+        if (it == null) {
+            collector.add(null)
+        } else {
+            collector.add(transform(it))
+        }
+    }
+    return collector.toColumn(name).cast()
+}
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/move.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/move.kt
new file mode 100644
index 000000000..cacbe2e02
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/move.kt
@@ -0,0 +1,72 @@
+package org.jetbrains.kotlinx.dataframe.impl.api
+
+import org.jetbrains.kotlinx.dataframe.AnyColumnReference
+import org.jetbrains.kotlinx.dataframe.ColumnSelector
+import org.jetbrains.kotlinx.dataframe.DataColumn
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl
+import org.jetbrains.kotlinx.dataframe.api.MoveClause
+import org.jetbrains.kotlinx.dataframe.api.cast
+import org.jetbrains.kotlinx.dataframe.api.getColumn
+import org.jetbrains.kotlinx.dataframe.api.getColumnGroup
+import org.jetbrains.kotlinx.dataframe.api.getColumnWithPath
+import org.jetbrains.kotlinx.dataframe.api.toDataFrame
+import org.jetbrains.kotlinx.dataframe.columns.ColumnWithPath
+import org.jetbrains.kotlinx.dataframe.columns.UnresolvedColumnsPolicy
+import org.jetbrains.kotlinx.dataframe.impl.DataFrameReceiver
+import org.jetbrains.kotlinx.dataframe.impl.columns.toColumnWithPath
+import org.jetbrains.kotlinx.dataframe.impl.columns.tree.ColumnPosition
+import org.jetbrains.kotlinx.dataframe.impl.columns.tree.getOrPut
+
+// TODO: support 'before' mode
+internal fun <T, C> MoveClause<T, C>.afterOrBefore(column: ColumnSelector<T, *>, isAfter: Boolean): DataFrame<T> {
+    val removeResult = df.removeImpl(columns = columns)
+
+    val targetPath = df.getColumnWithPath(column).path
+    val removeRoot = removeResult.removedColumns.first().getRoot()
+
+    val refNode = removeRoot.getOrPut(targetPath) {
+        val parentPath = it.dropLast(1)
+        val parent = if (parentPath.isEmpty()) df else df.getColumnGroup(parentPath)
+        val index = parent.getColumnIndex(it.last())
+        val col = df.getColumn(index)
+        ColumnPosition(index, false, col)
+    }
+
+    val parentPath = targetPath.dropLast(1)
+    val toInsert = removeResult.removedColumns.map {
+        val path = parentPath + it.name
+        ColumnToInsert(path, it.toColumnWithPath<C>().data, refNode)
+    }
+    return removeResult.df.insertImpl(toInsert)
+}
+
+internal fun <T, C> MoveClause<T, C>.moveImpl(
+    under: Boolean = false,
+    newPathExpression: ColumnsSelectionDsl<T>.(ColumnWithPath<C>) -> AnyColumnReference,
+): DataFrame<T> {
+    val receiver = object : DataFrameReceiver<T>(df, UnresolvedColumnsPolicy.Fail), ColumnsSelectionDsl<T> {}
+    val removeResult = df.removeImpl(columns = columns)
+    val columnsToInsert = removeResult.removedColumns.map {
+        val col = it.toColumnWithPath<C>()
+        var path = newPathExpression(receiver, col).path()
+        if (under) path += col.name()
+        ColumnToInsert(path, col.data, it)
+    }
+    return removeResult.df.insertImpl(columnsToInsert)
+}
+
+internal fun <T, C> MoveClause<T, C>.moveTo(columnIndex: Int): DataFrame<T> {
+    val removed = df.removeImpl(columns = columns)
+    val remainingColumns = removed.df.columns()
+    val targetIndex = if (columnIndex > remainingColumns.size) remainingColumns.size else columnIndex
+    val newColumnList =
+        remainingColumns.subList(0, targetIndex) +
+            removed.removedColumns.map { it.data.column as DataColumn<C> } +
+            if (targetIndex < remainingColumns.size) {
+                remainingColumns.subList(targetIndex, remainingColumns.size)
+            } else {
+                emptyList()
+            }
+    return newColumnList.toDataFrame().cast()
+}
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/pivot.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/pivot.kt
new file mode 100644
index 000000000..f115063f3
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/pivot.kt
@@ -0,0 +1,128 @@
+package org.jetbrains.kotlinx.dataframe.impl.api
+
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.Selector
+import org.jetbrains.kotlinx.dataframe.aggregation.AggregateDsl
+import org.jetbrains.kotlinx.dataframe.aggregation.NamedValue
+import org.jetbrains.kotlinx.dataframe.api.PivotColumnsSelector
+import org.jetbrains.kotlinx.dataframe.api.forEach
+import org.jetbrains.kotlinx.dataframe.api.groupBy
+import org.jetbrains.kotlinx.dataframe.api.toPath
+import org.jetbrains.kotlinx.dataframe.columns.ColumnPath
+import org.jetbrains.kotlinx.dataframe.columns.ColumnResolutionContext
+import org.jetbrains.kotlinx.dataframe.columns.ColumnSet
+import org.jetbrains.kotlinx.dataframe.columns.ColumnWithPath
+import org.jetbrains.kotlinx.dataframe.columns.ColumnsResolver
+import org.jetbrains.kotlinx.dataframe.columns.UnresolvedColumnsPolicy
+import org.jetbrains.kotlinx.dataframe.columns.toColumnSet
+import org.jetbrains.kotlinx.dataframe.impl.aggregation.GroupByReceiverImpl
+import org.jetbrains.kotlinx.dataframe.impl.aggregation.receivers.AggregateInternalDsl
+import org.jetbrains.kotlinx.dataframe.impl.aggregation.receivers.AggregatePivotDslImpl
+import org.jetbrains.kotlinx.dataframe.impl.columns.resolve
+import org.jetbrains.kotlinx.dataframe.impl.columns.toColumnSet
+
+internal class AggregatedPivot<T>(
+    private val df: DataFrame<T>,
+    val inward: Boolean?,
+    internal var aggregator: GroupByReceiverImpl<T>,
+) : DataFrame<T> by df
+
+internal data class PivotChainElement(val column: ColumnWithPath<Any?>, val includeColumnName: Boolean)
+
+internal class PivotChain<C>(val columns: List<PivotChainElement>, lastColumn: ColumnWithPath<C>) :
+    ColumnWithPath<C> by lastColumn
+
+internal class PivotChainColumnSet<C>(val first: ColumnsResolver<C>, val second: ColumnsResolver<C>) : ColumnSet<C> {
+
+    override fun resolve(context: ColumnResolutionContext): List<ColumnWithPath<C>> {
+        val firstCols = first.resolve(context)
+        val secondCols = second.resolve(context)
+        val result = mutableListOf<PivotChain<C>>()
+        firstCols.forEach { a ->
+            secondCols.forEach { b ->
+                val firstPart = ((a as? PivotChain<*>)?.columns ?: listOf(PivotChainElement(a, false)))
+                var secondPart = ((b as? PivotChain<*>)?.columns ?: listOf(PivotChainElement(b, false)))
+                if (secondCols.size > 1) {
+                    secondPart = listOf(PivotChainElement(secondPart[0].column, true)) + secondPart.drop(1)
+                }
+                result.add(PivotChain(firstPart + secondPart, b))
+            }
+        }
+        return result
+    }
+}
+
+internal fun <T, C> DataFrame<T>.getPivotSequences(
+    columns: PivotColumnsSelector<T, C>,
+): List<List<PivotChainElement>> =
+    columns.toColumnSet().resolve(this, UnresolvedColumnsPolicy.Fail)
+        .map {
+            when (val col = it) {
+                is PivotChain<*> -> col.columns as List<PivotChainElement>
+                else -> listOf(PivotChainElement(it, false))
+            }
+        }
+
+internal fun <T> DataFrame<T>.getPivotColumnPaths(columns: PivotColumnsSelector<T, *>): List<ColumnPath> =
+    getPivotSequences(columns).flatten().map { it.column.path }.distinct()
+
+internal fun <T, R> aggregatePivot(
+    aggregator: AggregateInternalDsl<T>,
+    columns: PivotColumnsSelector<T, *>,
+    separate: Boolean,
+    inward: Boolean? = null,
+    globalDefault: Any? = null,
+    body: Selector<AggregateDsl<T>, R>,
+) {
+    val pivotSequences = aggregator.df.getPivotSequences(columns)
+    val effectiveInward = inward ?: if (aggregator.hasGroupingKeys) {
+        true
+    } else {
+        pivotSequences.distinctBy { it.first().column.path }.count() > 1
+    }
+    pivotSequences.forEach { pivotColumns ->
+        aggregator.df.groupBy { pivotColumns.map { it.column }.toColumnSet() }.forEach { (key, group) ->
+
+            val pathNames = mutableListOf<String>()
+            key.values().forEachIndexed { i, v ->
+                if (i == 0 && effectiveInward) {
+                    pathNames.addAll(pivotColumns[i].column.path)
+                } else if (pivotColumns[i].includeColumnName) {
+                    pathNames.add(pivotColumns[i].column.name)
+                }
+                pathNames.add(v.toString())
+            }
+            val path = pathNames.toPath()
+            val builder = AggregatePivotDslImpl(group)
+            val result = body(builder, builder)
+            val hasResult = result != null && result != Unit
+
+            fun NamedValue.apply(path: ColumnPath) =
+                copy(
+                    path = path,
+                    value = this.value ?: default ?: globalDefault,
+                    default = default ?: globalDefault,
+                )
+
+            val values = builder.values
+            when {
+                values.size == 1 && values[0].path.isEmpty() -> aggregator.yield(values[0].apply(path))
+
+                values.isEmpty() -> aggregator.yield(
+                    path = path,
+                    value = if (hasResult) result else globalDefault,
+                    type = null,
+                    default = globalDefault,
+                    guessType = true,
+                )
+
+                else -> {
+                    values.forEach {
+                        val targetPath = if (separate) it.path + path else path + it.path
+                        aggregator.yield(it.apply(targetPath))
+                    }
+                }
+            }
+        }
+    }
+}
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/remove.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/remove.kt
new file mode 100644
index 000000000..06e302dcf
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/remove.kt
@@ -0,0 +1,85 @@
+package org.jetbrains.kotlinx.dataframe.impl.api
+
+import org.jetbrains.kotlinx.dataframe.AnyBaseCol
+import org.jetbrains.kotlinx.dataframe.AnyFrame
+import org.jetbrains.kotlinx.dataframe.ColumnsSelector
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.api.cast
+import org.jetbrains.kotlinx.dataframe.api.name
+import org.jetbrains.kotlinx.dataframe.api.toDataFrame
+import org.jetbrains.kotlinx.dataframe.columns.ColumnGroup
+import org.jetbrains.kotlinx.dataframe.columns.ColumnWithPath
+import org.jetbrains.kotlinx.dataframe.columns.UnresolvedColumnsPolicy
+import org.jetbrains.kotlinx.dataframe.impl.columns.tree.ColumnPosition
+import org.jetbrains.kotlinx.dataframe.impl.columns.tree.TreeNode
+import org.jetbrains.kotlinx.dataframe.impl.columns.tree.allRemovedColumns
+import org.jetbrains.kotlinx.dataframe.impl.columns.withDf
+import org.jetbrains.kotlinx.dataframe.impl.getColumnsWithPaths
+import org.jetbrains.kotlinx.dataframe.nrow
+
+internal data class RemoveResult<T>(val df: DataFrame<T>, val removedColumns: List<TreeNode<ColumnPosition>>)
+
+internal fun <T> DataFrame<T>.removeImpl(
+    allowMissingColumns: Boolean = false,
+    columns: ColumnsSelector<T, *>,
+): RemoveResult<T> {
+    val colWithPaths = getColumnsWithPaths(
+        unresolvedColumnsPolicy =
+            if (allowMissingColumns) {
+                UnresolvedColumnsPolicy.Skip
+            } else {
+                UnresolvedColumnsPolicy.Fail
+            },
+        selector = columns,
+    )
+    val colPaths = colWithPaths.map { it.path }
+    val originalOrder = colPaths.mapIndexed { index, path -> path to index }.toMap()
+
+    val root = TreeNode.createRoot(ColumnPosition(-1, false, null))
+
+    if (colPaths.isEmpty()) return RemoveResult(this, emptyList())
+
+    fun dfs(
+        cols: Iterable<AnyBaseCol>,
+        removePaths: List<ColumnWithPath<*>>,
+        node: TreeNode<ColumnPosition>,
+    ): AnyFrame? {
+        if (removePaths.isEmpty()) return null
+
+        val depth = node.depth
+        val childrenToRemove = removePaths.groupBy { it.path[depth] }
+        val newCols = mutableListOf<AnyBaseCol>()
+
+        cols.forEachIndexed { index, column ->
+            val toRemove = childrenToRemove[column.name()]
+            if (toRemove != null) {
+                val node = node.addChild(column.name, ColumnPosition(index, true, null))
+                if (toRemove.all { it.path.size > depth + 1 }) {
+                    val groupCol = (column as ColumnGroup<*>)
+                    val newDf = dfs(groupCol.columns(), toRemove, node)
+                    if (newDf != null) {
+                        val newCol = groupCol.withDf(newDf)
+                        newCols.add(newCol)
+                        node.data.wasRemoved = false
+                    }
+                } else {
+                    val removedChild = toRemove.single { it.path.size == depth + 1 }
+                    node.data.column = removedChild.data
+                }
+            } else {
+                newCols.add(column)
+            }
+        }
+        if (newCols.isEmpty()) return null
+        return newCols.toDataFrame()
+    }
+
+    val newDf = dfs(columns(), colWithPaths, root) ?: DataFrame.empty(nrow)
+
+    val removedColumns = root.allRemovedColumns()
+        .map { it.pathFromRoot() to it }
+        .sortedBy { originalOrder[it.first] }
+        .map { it.second }
+
+    return RemoveResult(newDf.cast(), removedColumns)
+}
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/rename.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/rename.kt
new file mode 100644
index 000000000..b0460b6f3
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/rename.kt
@@ -0,0 +1,59 @@
+package org.jetbrains.kotlinx.dataframe.impl.api
+
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.api.RenameClause
+import org.jetbrains.kotlinx.dataframe.api.asColumnGroup
+import org.jetbrains.kotlinx.dataframe.api.cast
+import org.jetbrains.kotlinx.dataframe.api.getColumnsWithPaths
+import org.jetbrains.kotlinx.dataframe.api.toDataFrame
+import org.jetbrains.kotlinx.dataframe.columns.ColumnGroup
+import org.jetbrains.kotlinx.dataframe.columns.ColumnKind
+import org.jetbrains.kotlinx.dataframe.columns.ColumnWithPath
+import org.jetbrains.kotlinx.dataframe.impl.columns.tree.allChildrenNotNull
+import org.jetbrains.kotlinx.dataframe.impl.columns.tree.collectTree
+import org.jetbrains.kotlinx.dataframe.impl.columns.tree.map
+import org.jetbrains.kotlinx.dataframe.kind
+
+internal fun <T, C> RenameClause<T, C>.renameImpl(newNames: Array<out String>): DataFrame<T> {
+    var i = 0
+    return renameImpl { newNames[i++] }
+}
+
+internal fun <T, C> RenameClause<T, C>.renameImpl(transform: (ColumnWithPath<C>) -> String): DataFrame<T> {
+    // get all selected columns and their paths
+    val selectedColumnsWithPath = df.getColumnsWithPaths(columns)
+        .associateBy { it.path }
+    // gather a tree of all columns where the nodes will be renamed
+    val tree = df.getColumnsWithPaths { colsAtAnyDepth() }.collectTree()
+
+    // perform rename in nodes
+    tree.allChildrenNotNull().map { it to it.pathFromRoot() }.forEach { (node, originalPath) ->
+        // Check if the current node/column is a selected column and, if so, get its ColumnWithPath
+        val column = selectedColumnsWithPath[originalPath] ?: return@forEach
+        // Use the found selected ColumnWithPath to query for the new name
+        val newColumnName = transform(column)
+        node.name = newColumnName
+    }
+
+    // use the mapping function to convert the tree to a ColumnGroup/ValueColumn structure
+    // The result will be a ColumnGroup, since the root node's data is null
+    val renamedDfAsColumnGroup = tree.map { node, children ->
+        val col = node.data
+        when (col?.kind) {
+            // if the column is a value column or a frame column, rename it using the node's (new) name
+            ColumnKind.Value, ColumnKind.Frame ->
+                col.rename(node.name)
+
+            // if the column is a group column, create a new column group using the node's (new) name and children
+            // if the column is null, node is the root, so we'll create a column group as well
+            ColumnKind.Group, null ->
+                children
+                    .toDataFrame()
+                    .asColumnGroup(node.name)
+        }
+    } as ColumnGroup<*>
+
+    // convert the created ColumnGroup to a DataFrame
+    val renamedDf = renamedDfAsColumnGroup.columns().toDataFrame()
+    return renamedDf.cast()
+}
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/reorder.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/reorder.kt
new file mode 100644
index 000000000..e5c8accd4
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/reorder.kt
@@ -0,0 +1,78 @@
+package org.jetbrains.kotlinx.dataframe.impl.api
+
+import org.jetbrains.kotlinx.dataframe.AnyFrame
+import org.jetbrains.kotlinx.dataframe.ColumnExpression
+import org.jetbrains.kotlinx.dataframe.DataColumn
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.api.Reorder
+import org.jetbrains.kotlinx.dataframe.api.asColumnGroup
+import org.jetbrains.kotlinx.dataframe.api.cast
+import org.jetbrains.kotlinx.dataframe.api.getColumnGroup
+import org.jetbrains.kotlinx.dataframe.api.getColumnsWithPaths
+import org.jetbrains.kotlinx.dataframe.api.isColumnGroup
+import org.jetbrains.kotlinx.dataframe.api.isFrameColumn
+import org.jetbrains.kotlinx.dataframe.api.map
+import org.jetbrains.kotlinx.dataframe.api.reorder
+import org.jetbrains.kotlinx.dataframe.api.replace
+import org.jetbrains.kotlinx.dataframe.api.with
+import org.jetbrains.kotlinx.dataframe.columns.toColumnSet
+import org.jetbrains.kotlinx.dataframe.impl.columns.asAnyFrameColumn
+import org.jetbrains.kotlinx.dataframe.impl.columns.tree.ColumnPosition
+import org.jetbrains.kotlinx.dataframe.impl.columns.tree.TreeNode
+import kotlin.reflect.typeOf
+
+internal fun <T, C, V : Comparable<V>> Reorder<T, C>.reorderImpl(
+    desc: Boolean,
+    expression: ColumnExpression<C, V>,
+): DataFrame<T> {
+    data class ColumnInfo(
+        val treeNode: TreeNode<ColumnPosition>,
+        val column: DataColumn<C>,
+        val value: V,
+        val index: Int,
+    )
+
+    val columnsWithPaths = df.getColumnsWithPaths(columns)
+    if (columnsWithPaths.size == 1 && columnsWithPaths[0].isColumnGroup()) {
+        val path = columnsWithPaths[0].path
+        return df.reorder { path.allCols().cast<C>() }.reorderImpl(desc, expression)
+    }
+
+    var df = df
+
+    columnsWithPaths
+        .groupBy({ it.path.parent()!! }) { it.name() }
+        .forEach { (parentPath, names) ->
+            val group = if (parentPath.isEmpty()) df else df.getColumnGroup(parentPath)
+
+            val removed = group.removeImpl(false) { names.toColumnSet() }
+
+            val mapped = removed.removedColumns
+                .sortedBy { group.getColumnIndex(it.name) }
+                .mapIndexed { i, treeNode ->
+                    val column = treeNode.data.column!!.cast<C>()
+                    ColumnInfo(treeNode, column, expression(column, column), i)
+                }
+
+            val sorted = if (desc) mapped.sortedByDescending { it.value } else mapped.sortedBy { it.value }
+
+            val toInsert = sorted.mapIndexed { i, c ->
+                val src = mapped[i]
+                val path = src.treeNode.pathFromRoot().rename(c.column.name())
+                var column = c.column
+                if (inFrameColumns && column.isFrameColumn()) {
+                    column = column.asAnyFrameColumn()
+                        .map(typeOf<AnyFrame>()) { it.cast<T>().reorder(columns).reorderImpl(desc, expression) }
+                        .cast()
+                }
+                ColumnToInsert(path, column, src.treeNode)
+            }
+            val newGroup = removed.df.insertImpl(toInsert)
+            df = if (parentPath.isEmpty()) {
+                newGroup.cast()
+            } else {
+                df.replace(parentPath).with { newGroup.asColumnGroup(it.name()) }
+            }
+        }
+    return df
+}
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/sort.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/sort.kt
new file mode 100644
index 000000000..336c2db7d
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/sort.kt
@@ -0,0 +1,125 @@
+package org.jetbrains.kotlinx.dataframe.impl.api
+
+import org.jetbrains.kotlinx.dataframe.AnyCol
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.api.GroupBy
+import org.jetbrains.kotlinx.dataframe.api.SortColumnsSelector
+import org.jetbrains.kotlinx.dataframe.api.asGroupBy
+import org.jetbrains.kotlinx.dataframe.api.castFrameColumn
+import org.jetbrains.kotlinx.dataframe.api.getFrameColumn
+import org.jetbrains.kotlinx.dataframe.api.toDataFrame
+import org.jetbrains.kotlinx.dataframe.api.update
+import org.jetbrains.kotlinx.dataframe.api.with
+import org.jetbrains.kotlinx.dataframe.columns.ColumnResolutionContext
+import org.jetbrains.kotlinx.dataframe.columns.ColumnSet
+import org.jetbrains.kotlinx.dataframe.columns.ColumnWithPath
+import org.jetbrains.kotlinx.dataframe.columns.ColumnsResolver
+import org.jetbrains.kotlinx.dataframe.columns.UnresolvedColumnsPolicy
+import org.jetbrains.kotlinx.dataframe.columns.ValueColumn
+import org.jetbrains.kotlinx.dataframe.impl.columns.addPath
+import org.jetbrains.kotlinx.dataframe.impl.columns.assertIsComparable
+import org.jetbrains.kotlinx.dataframe.impl.columns.missing.MissingColumnGroup
+import org.jetbrains.kotlinx.dataframe.impl.columns.resolve
+import org.jetbrains.kotlinx.dataframe.impl.columns.toColumnSet
+import org.jetbrains.kotlinx.dataframe.kind
+import org.jetbrains.kotlinx.dataframe.nrow
+
+@Suppress("UNCHECKED_CAST", "RemoveExplicitTypeArguments")
+internal fun <T, G> GroupBy<T, G>.sortByImpl(columns: SortColumnsSelector<G, *>): GroupBy<T, G> =
+    toDataFrame()
+        // sort the individual groups by the columns specified
+        .update { groups }
+        .with { it.sortByImpl(UnresolvedColumnsPolicy.Skip, columns) }
+        // sort the groups by the columns specified (must be either be the keys column or "groups")
+        // will do nothing if the columns specified are not the keys column or "groups"
+        .sortByImpl(UnresolvedColumnsPolicy.Skip, columns as SortColumnsSelector<T, *>)
+        .asGroupBy { it.getFrameColumn(groups.name()).castFrameColumn<G>() }
+
+internal fun <T, C> DataFrame<T>.sortByImpl(
+    unresolvedColumnsPolicy: UnresolvedColumnsPolicy = UnresolvedColumnsPolicy.Fail,
+    columns: SortColumnsSelector<T, C>,
+): DataFrame<T> {
+    val sortColumns = getSortColumns(columns, unresolvedColumnsPolicy)
+    if (sortColumns.isEmpty()) return this
+
+    val compChain = sortColumns.map {
+        when (it.direction) {
+            SortDirection.Asc -> it.column.createComparator(it.nullsLast)
+            SortDirection.Desc -> it.column.createComparator(it.nullsLast).reversed()
+        }
+    }.reduce { a, b -> a.then(b) }
+
+    val permutation = (0 until nrow).sortedWith(compChain)
+
+    return this[permutation]
+}
+
+internal fun AnyCol.createComparator(nullsLast: Boolean): java.util.Comparator<Int> {
+    assertIsComparable()
+
+    val valueComparator = Comparator<Any?> { left, right ->
+        (left as Comparable<Any?>).compareTo(right)
+    }
+
+    val comparatorWithNulls = if (nullsLast) nullsLast(valueComparator) else nullsFirst(valueComparator)
+    return Comparator { left, right -> comparatorWithNulls.compare(get(left), get(right)) }
+}
+
+internal fun <T, C> DataFrame<T>.getSortColumns(
+    columns: SortColumnsSelector<T, C>,
+    unresolvedColumnsPolicy: UnresolvedColumnsPolicy,
+): List<SortColumnDescriptor<*>> =
+    columns.toColumnSet().resolve(this, unresolvedColumnsPolicy)
+        // can appear using [DataColumn<R>?.check] with UnresolvedColumnsPolicy.Skip
+        .filterNot { it.data is MissingColumnGroup<*> }
+        .map {
+            when (val col = it.data) {
+                is SortColumnDescriptor<*> -> col
+                is ValueColumn<*> -> SortColumnDescriptor(col)
+                else -> throw IllegalStateException("Can not use ${col.kind} as sort column")
+            }
+        }
+
+internal enum class SortFlag { Reversed, NullsLast }
+
+internal fun <C> ColumnsResolver<C>.addFlag(flag: SortFlag): ColumnSetWithSortFlag<C> =
+    ColumnSetWithSortFlag(this, flag)
+
+internal fun <C> ColumnWithPath<C>.addFlag(flag: SortFlag): ColumnWithPath<C> {
+    val col = data
+    return when (col) {
+        is SortColumnDescriptor -> {
+            when (flag) {
+                SortFlag.Reversed -> SortColumnDescriptor(col.column, col.direction.reversed(), col.nullsLast)
+                SortFlag.NullsLast -> SortColumnDescriptor(col.column, col.direction, true)
+            }
+        }
+
+        is ValueColumn -> {
+            when (flag) {
+                SortFlag.Reversed -> SortColumnDescriptor(col, SortDirection.Desc)
+                SortFlag.NullsLast -> SortColumnDescriptor(col, SortDirection.Asc, true)
+            }
+        }
+
+        else -> throw IllegalArgumentException("Can not apply sort flag to column kind ${col.kind}")
+    }.addPath(path)
+}
+
+internal class ColumnSetWithSortFlag<C>(val column: ColumnsResolver<C>, val flag: SortFlag) : ColumnSet<C> {
+    override fun resolve(context: ColumnResolutionContext) = column.resolve(context).map { it.addFlag(flag) }
+}
+
+internal class SortColumnDescriptor<C>(
+    val column: ValueColumn<C>,
+    val direction: SortDirection = SortDirection.Asc,
+    val nullsLast: Boolean = false,
+) : ValueColumn<C> by column
+
+internal enum class SortDirection { Asc, Desc }
+
+internal fun SortDirection.reversed(): SortDirection =
+    when (this) {
+        SortDirection.Asc -> SortDirection.Desc
+        SortDirection.Desc -> SortDirection.Asc
+    }
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/split.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/split.kt
new file mode 100644
index 000000000..bbb411cb1
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/split.kt
@@ -0,0 +1,104 @@
+package org.jetbrains.kotlinx.dataframe.impl.api
+
+import org.jetbrains.kotlinx.dataframe.AnyFrame
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.api.SplitWithTransform
+import org.jetbrains.kotlinx.dataframe.api.rows
+import org.jetbrains.kotlinx.dataframe.columns.ColumnPath
+import org.jetbrains.kotlinx.dataframe.columns.ColumnWithPath
+import org.jetbrains.kotlinx.dataframe.impl.ColumnDataCollector
+import org.jetbrains.kotlinx.dataframe.impl.columns.toColumnWithPath
+import org.jetbrains.kotlinx.dataframe.impl.createDataCollector
+import org.jetbrains.kotlinx.dataframe.nrow
+
+internal fun valueToList(value: Any?, splitStrings: Boolean = true): List<Any?> =
+    when (value) {
+        null -> emptyList()
+        is List<*> -> value
+        is AnyFrame -> value.rows().toList()
+        else -> if (splitStrings) value.toString().split(",").map { it.trim() } else listOf(value)
+    }
+
+internal fun <T, C, R> splitImpl(
+    clause: SplitWithTransform<T, C, R>,
+    columnNamesGenerator: ColumnWithPath<C>.(Int) -> List<String>,
+): DataFrame<T> {
+    val nrow = clause.df.nrow
+
+    val removeResult = clause.df.removeImpl(columns = clause.columns)
+
+    // As we insert multiple columns at once it's possible to encounter a name conflict within a batch of a new columns
+    // that's why an old school mutable list is used here to check for name conflicts in intermediate steps of generation
+    // of columns to insert
+    val columnsToInsert = mutableListOf<ColumnToInsert>()
+
+    removeResult.removedColumns.forEach { node ->
+
+        val column = node.toColumnWithPath<C>()
+        val columnCollectors = mutableListOf<ColumnDataCollector>()
+        for (row in 0 until nrow) {
+            val value = clause.transform(clause.df[row], column.data[row])
+            val list = valueToList(value)
+            for (j in list.indices) {
+                if (columnCollectors.size <= j) {
+                    val collector = createDataCollector(nrow)
+                    repeat(row) { collector.add(clause.default) }
+                    columnCollectors.add(collector)
+                }
+                columnCollectors[j].add(list[j])
+            }
+            for (j in list.size until columnCollectors.size) {
+                columnCollectors[j].add(clause.default)
+            }
+        }
+
+        val names = columnNamesGenerator(column, columnCollectors.size)
+        val sourcePath = node.pathFromRoot()
+
+        columnCollectors.forEachIndexed { i, col ->
+            val preferredName = names.getOrNull(i)
+
+            val pathToInsert = if (clause.inward) sourcePath else sourcePath.dropLast(1)
+            val name = generateUnusedName(removeResult.df, preferredName, pathToInsert, columnsToInsert)
+
+            val path = pathToInsert + name
+
+            val data = col.toColumn(name)
+            columnsToInsert.add(ColumnToInsert(path, data, node))
+        }
+    }
+
+    return removeResult.df.insertImpl(columnsToInsert)
+}
+
+internal fun generateUnusedName(
+    df: DataFrame<*>,
+    preferredName: String?,
+    insertPath: ColumnPath,
+    columnsToBeInserted: List<ColumnToInsert>,
+): String {
+    // check if column with this name already exists in the df in the same position in the hierarchy,
+    // or we already have a column with this name in the list of columns to be inserted to the same position in the hierarchy
+    fun isUsed(name: String) =
+        df.getColumnOrNull(insertPath + name) != null ||
+            columnsToBeInserted.any { it.insertionPath == insertPath + name }
+
+    fun generateNameVariationByTryingNumericSuffixes(original: String? = null, startSuffix: Int): String {
+        var k = startSuffix
+        var name = original ?: "split$k"
+        while (isUsed(name)) {
+            name = original ?: "split"
+            name = "${name}${k++}"
+        }
+
+        return name
+    }
+
+    return if (preferredName == null) {
+        generateNameVariationByTryingNumericSuffixes(startSuffix = 1)
+    } else {
+        generateNameVariationByTryingNumericSuffixes(preferredName, 1)
+    }
+}
+
+internal fun String.splitDefault() = split(",").map { it.trim() }
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/toDataFrame.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/toDataFrame.kt
new file mode 100644
index 000000000..87fe03866
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/toDataFrame.kt
@@ -0,0 +1,357 @@
+package org.jetbrains.kotlinx.dataframe.impl.api
+
+import org.jetbrains.kotlinx.dataframe.AnyBaseCol
+import org.jetbrains.kotlinx.dataframe.AnyFrame
+import org.jetbrains.kotlinx.dataframe.AnyRow
+import org.jetbrains.kotlinx.dataframe.DataColumn
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.DataRow
+import org.jetbrains.kotlinx.dataframe.api.CreateDataFrameDsl
+import org.jetbrains.kotlinx.dataframe.api.TraversePropertiesDsl
+import org.jetbrains.kotlinx.dataframe.api.concat
+import org.jetbrains.kotlinx.dataframe.api.dataFrameOf
+import org.jetbrains.kotlinx.dataframe.api.toDataFrameFromPairs
+import org.jetbrains.kotlinx.dataframe.codeGen.getFieldKind
+import org.jetbrains.kotlinx.dataframe.columns.ColumnPath
+import org.jetbrains.kotlinx.dataframe.impl.asList
+import org.jetbrains.kotlinx.dataframe.impl.columnName
+import org.jetbrains.kotlinx.dataframe.impl.emptyPath
+import org.jetbrains.kotlinx.dataframe.impl.getListType
+import org.jetbrains.kotlinx.dataframe.impl.isArray
+import org.jetbrains.kotlinx.dataframe.impl.isGetterLike
+import org.jetbrains.kotlinx.dataframe.impl.projectUpTo
+import org.jetbrains.kotlinx.dataframe.impl.schema.sortWithConstructor
+import java.lang.reflect.InvocationTargetException
+import java.lang.reflect.Method
+import java.time.temporal.Temporal
+import kotlin.reflect.KCallable
+import kotlin.reflect.KClass
+import kotlin.reflect.KProperty
+import kotlin.reflect.KVisibility
+import kotlin.reflect.full.isSubclassOf
+import kotlin.reflect.full.memberFunctions
+import kotlin.reflect.full.memberProperties
+import kotlin.reflect.full.primaryConstructor
+import kotlin.reflect.full.withNullability
+import kotlin.reflect.jvm.isAccessible
+import kotlin.reflect.jvm.javaField
+import kotlin.reflect.typeOf
+
+private val valueTypes = setOf(
+    String::class,
+    Boolean::class,
+    kotlin.time.Duration::class,
+    kotlinx.datetime.LocalDate::class,
+    kotlinx.datetime.LocalDateTime::class,
+    kotlinx.datetime.Instant::class,
+)
+
+internal val KClass<*>.isValueType: Boolean
+    get() =
+        this in valueTypes ||
+            this.isSubclassOf(Number::class) ||
+            this.isSubclassOf(Enum::class) ||
+            this.isSubclassOf(Temporal::class) ||
+            this.isArray
+
+internal class CreateDataFrameDslImpl<T>(
+    override val source: Iterable<T>,
+    private val clazz: KClass<*>,
+    private val prefix: ColumnPath = emptyPath(),
+    private val configuration: TraverseConfiguration = TraverseConfiguration(),
+) : CreateDataFrameDsl<T>(),
+    TraversePropertiesDsl by configuration {
+
+    internal val columns = mutableListOf<Pair<ColumnPath, AnyBaseCol>>()
+
+    override fun add(column: AnyBaseCol, path: ColumnPath?) {
+        val col = if (path != null) column.rename(path.last()) else column
+        val targetPath = if (path != null) prefix + path else prefix + column.name()
+        columns.add(targetPath to col)
+    }
+
+    override operator fun String.invoke(builder: CreateDataFrameDsl<T>.() -> Unit) {
+        val child = CreateDataFrameDslImpl(source, clazz, prefix + this)
+        builder(child)
+        columns.addAll(child.columns)
+    }
+
+    internal class TraverseConfiguration : TraversePropertiesDsl {
+
+        val excludeProperties = mutableSetOf<KCallable<*>>()
+
+        val excludeClasses = mutableSetOf<KClass<*>>()
+
+        val preserveClasses = mutableSetOf<KClass<*>>()
+
+        val preserveProperties = mutableSetOf<KCallable<*>>()
+
+        fun clone(): TraverseConfiguration =
+            TraverseConfiguration().also {
+                it.excludeClasses.addAll(excludeClasses)
+                it.excludeProperties.addAll(excludeProperties)
+                it.preserveProperties.addAll(preserveProperties)
+                it.preserveClasses.addAll(preserveClasses)
+            }
+
+        override fun exclude(vararg properties: KCallable<*>) {
+            for (prop in properties) {
+                require(prop.isGetterLike()) {
+                    "${prop.name} is not a property or getter-like function. Only those are traversed and can be excluded."
+                }
+            }
+            excludeProperties.addAll(properties)
+        }
+
+        override fun exclude(vararg classes: KClass<*>) {
+            excludeClasses.addAll(classes)
+        }
+
+        override fun preserve(vararg classes: KClass<*>) {
+            preserveClasses.addAll(classes)
+        }
+
+        override fun preserve(vararg properties: KCallable<*>) {
+            for (prop in properties) {
+                require(prop.isGetterLike()) {
+                    "${prop.name} is not a property or getter-like function. Only those are traversed and can be preserved."
+                }
+            }
+            preserveProperties.addAll(properties)
+        }
+    }
+
+    override fun properties(vararg roots: KCallable<*>, maxDepth: Int, body: (TraversePropertiesDsl.() -> Unit)?) {
+        for (prop in roots) {
+            require(prop.isGetterLike()) {
+                "${prop.name} is not a property or getter-like function. Only those are traversed and can be added as roots."
+            }
+        }
+
+        val dsl = configuration.clone()
+        if (body != null) {
+            body(dsl)
+        }
+        val df = convertToDataFrame(
+            data = source,
+            clazz = clazz,
+            roots = roots.toList(),
+            excludes = dsl.excludeProperties,
+            preserveClasses = dsl.preserveClasses,
+            preserveProperties = dsl.preserveProperties,
+            maxDepth = maxDepth,
+        )
+        df.columns().forEach {
+            add(it)
+        }
+    }
+}
+
+@PublishedApi
+internal fun <T> Iterable<T>.createDataFrameImpl(
+    clazz: KClass<*>,
+    body: CreateDataFrameDslImpl<T>.() -> Unit,
+): DataFrame<T> {
+    val builder = CreateDataFrameDslImpl(this, clazz)
+    builder.body()
+    return builder.columns.toDataFrameFromPairs()
+}
+
+@PublishedApi
+internal fun convertToDataFrame(
+    data: Iterable<*>,
+    clazz: KClass<*>,
+    roots: List<KCallable<*>>,
+    excludes: Set<KCallable<*>>,
+    preserveClasses: Set<KClass<*>>,
+    preserveProperties: Set<KCallable<*>>,
+    maxDepth: Int,
+): AnyFrame {
+    val properties: List<KCallable<*>> = roots
+        .ifEmpty {
+            clazz.memberProperties
+                .filter { it.visibility == KVisibility.PUBLIC }
+        }
+        // fall back to getter functions for pojo-like classes if no member properties were found
+        .ifEmpty {
+            clazz.memberFunctions
+                .filter { it.visibility == KVisibility.PUBLIC && it.isGetterLike() }
+        }
+        // sort properties by order in constructor
+        .sortWithConstructor(clazz)
+
+    val columns = properties.mapNotNull {
+        val property = it
+        if (excludes.contains(property)) return@mapNotNull null
+
+        class ValueClassConverter(val unbox: Method, val box: Method)
+
+        val valueClassConverter = (it.returnType.classifier as? KClass<*>)?.let { kClass ->
+            if (!kClass.isValue) return@let null
+
+            val constructor = requireNotNull(kClass.primaryConstructor) {
+                "value class $kClass is expected to have primary constructor, but couldn't obtain it"
+            }
+            val parameter = constructor.parameters.singleOrNull()
+                ?: error(
+                    "conversion of value class $kClass with multiple parameters in constructor is not yet supported",
+                )
+            // there's no need to unwrap if underlying field is nullable
+            if (parameter.type.isMarkedNullable) return@let null
+            // box and unbox impl methods are part of binary API of value classes
+            // https://youtrack.jetbrains.com/issue/KT-50518/Boxing-Unboxing-methods-for-JvmInline-value-classes-should-be-public-accessible
+            val unbox = kClass.java.getMethod("unbox-impl")
+            val box = kClass.java.methods.single { it.name == "box-impl" }
+            val valueClassConverter = ValueClassConverter(unbox, box)
+            valueClassConverter
+        }
+        (property as? KProperty<*>)?.javaField?.isAccessible = true
+        property.isAccessible = true
+
+        var nullable = false
+        var hasExceptions = false
+        val values = data.map { obj ->
+            if (obj == null) {
+                nullable = true
+                null
+            } else {
+                val value = try {
+                    val value = it.call(obj)
+                    /*
+                     * here we do what compiler does
+                     * @see org.jetbrains.kotlinx.dataframe.api.CreateDataFrameTests.testKPropertyGetLibrary
+                     */
+                    if (valueClassConverter != null) {
+                        val var1 = value?.let {
+                            valueClassConverter.unbox.invoke(it)
+                        }
+                        var1?.let { valueClassConverter.box.invoke(null, var1) }
+                    } else {
+                        value
+                    }
+                } catch (e: InvocationTargetException) {
+                    hasExceptions = true
+                    e.targetException
+                } catch (e: Throwable) {
+                    hasExceptions = true
+                    e
+                }
+                if (value == null) nullable = true
+                value
+            }
+        }
+
+        val returnType = property.returnType.let { type ->
+            if (type.classifier is KClass<*>) {
+                type
+            } else {
+                typeOf<Any>()
+            }
+        }
+        val kClass = returnType.classifier as KClass<*>
+        val fieldKind = returnType.getFieldKind()
+
+        val keepSubtree =
+            maxDepth <= 0 && !fieldKind.shouldBeConvertedToFrameColumn && !fieldKind.shouldBeConvertedToColumnGroup
+        val shouldCreateValueCol = keepSubtree ||
+            kClass == Any::class ||
+            kClass in preserveClasses ||
+            property in preserveProperties ||
+            kClass.isValueType
+
+        val shouldCreateFrameCol = kClass == DataFrame::class && !nullable
+        val shouldCreateColumnGroup = kClass == DataRow::class
+
+        when {
+            hasExceptions -> DataColumn.createWithTypeInference(it.columnName, values, nullable)
+
+            shouldCreateValueCol ->
+                DataColumn.createValueColumn(
+                    name = it.columnName,
+                    values = values,
+                    type = returnType.withNullability(nullable),
+                )
+
+            shouldCreateFrameCol ->
+                DataColumn.createFrameColumn(
+                    name = it.columnName,
+                    groups = values as List<AnyFrame>,
+                )
+
+            shouldCreateColumnGroup ->
+                DataColumn.createColumnGroup(
+                    name = it.columnName,
+                    df = (values as List<AnyRow>).concat(),
+                )
+
+            kClass.isSubclassOf(Iterable::class) ->
+                when (val elementType = returnType.projectUpTo(Iterable::class).arguments.firstOrNull()?.type) {
+                    null ->
+                        DataColumn.createValueColumn(
+                            name = it.columnName,
+                            values = values,
+                            type = returnType.withNullability(nullable),
+                        )
+
+                    else -> {
+                        val elementClass = elementType.classifier as? KClass<*>
+                        when {
+                            elementClass == null -> {
+                                val listValues = values.map {
+                                    (it as? Iterable<*>)?.asList()
+                                }
+
+                                DataColumn.createWithTypeInference(it.columnName, listValues)
+                            }
+
+                            elementClass.isValueType -> {
+                                val listType = getListType(elementType).withNullability(nullable)
+                                val listValues = values.map {
+                                    (it as? Iterable<*>)?.asList()
+                                }
+                                DataColumn.createValueColumn(it.columnName, listValues, listType)
+                            }
+
+                            else -> {
+                                val frames = values.map {
+                                    if (it == null) {
+                                        DataFrame.empty()
+                                    } else {
+                                        require(it is Iterable<*>)
+                                        convertToDataFrame(
+                                            data = it,
+                                            clazz = elementClass,
+                                            roots = emptyList(),
+                                            excludes = excludes,
+                                            preserveClasses = preserveClasses,
+                                            preserveProperties = preserveProperties,
+                                            maxDepth = maxDepth - 1,
+                                        )
+                                    }
+                                }
+                                DataColumn.createFrameColumn(it.columnName, frames)
+                            }
+                        }
+                    }
+                }
+
+            else -> {
+                val df = convertToDataFrame(
+                    data = values,
+                    clazz = kClass,
+                    roots = emptyList(),
+                    excludes = excludes,
+                    preserveClasses = preserveClasses,
+                    preserveProperties = preserveProperties,
+                    maxDepth = maxDepth - 1,
+                )
+                DataColumn.createColumnGroup(name = it.columnName, df = df)
+            }
+        }
+    }
+    return if (columns.isEmpty()) {
+        DataFrame.empty(data.count())
+    } else {
+        dataFrameOf(columns)
+    }
+}
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/toList.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/toList.kt
new file mode 100644
index 000000000..fcf4b6cff
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/toList.kt
@@ -0,0 +1,83 @@
+package org.jetbrains.kotlinx.dataframe.impl.api
+
+import org.jetbrains.kotlinx.dataframe.AnyCol
+import org.jetbrains.kotlinx.dataframe.AnyFrame
+import org.jetbrains.kotlinx.dataframe.DataColumn
+import org.jetbrains.kotlinx.dataframe.api.asColumnGroup
+import org.jetbrains.kotlinx.dataframe.api.convertTo
+import org.jetbrains.kotlinx.dataframe.api.getColumn
+import org.jetbrains.kotlinx.dataframe.api.map
+import org.jetbrains.kotlinx.dataframe.api.rows
+import org.jetbrains.kotlinx.dataframe.columns.ColumnKind
+import org.jetbrains.kotlinx.dataframe.impl.columnName
+import org.jetbrains.kotlinx.dataframe.impl.columns.asAnyFrameColumn
+import org.jetbrains.kotlinx.dataframe.kind
+import org.jetbrains.kotlinx.dataframe.type
+import kotlin.reflect.KType
+import kotlin.reflect.full.isSubtypeOf
+import kotlin.reflect.full.memberProperties
+import kotlin.reflect.full.primaryConstructor
+import kotlin.reflect.full.withNullability
+import kotlin.reflect.jvm.jvmErasure
+
+@PublishedApi
+internal fun AnyFrame.toListImpl(type: KType): List<Any> {
+    val clazz = type.jvmErasure
+    require(clazz.isData) { "`$clazz` is not a data class. `toList` is supported only for data classes." }
+
+    val constructor = clazz.primaryConstructor
+    require(constructor != null) { "Class `$clazz` doesn't have a primary constructor" }
+
+    val columnNames = clazz.memberProperties.associate { it.name to it.columnName }
+
+    val convertedColumns = constructor.parameters.map {
+        require(it.name != null) { "Parameter name can not be null. Parameter = $it" }
+        val columnName = columnNames[it.name]
+
+        check(columnName != null) { "Can not find member property for parameter ${it.name}" }
+        val index = getColumnIndex(columnName)
+
+        check(index >= 0) { "Can not find column `$columnName` in DataFrame" }
+
+        val column = getColumn(index)
+        val convertedColumn = if (column.type != it.type) {
+            when (column.kind) {
+                ColumnKind.Frame -> {
+                    val col: AnyCol = if (it.type.jvmErasure == List::class) {
+                        val elementType = it.type.arguments[0].type
+                        require(elementType != null) { "FrameColumn can not be converted to type `List<*>`" }
+                        column.asAnyFrameColumn().map { it.toListImpl(elementType) }
+                    } else {
+                        error("FrameColumn can not be converted to type `${it.type}`")
+                    }
+                    col
+                }
+
+                ColumnKind.Group -> {
+                    DataColumn.createValueColumn(column.name(), column.asColumnGroup().toListImpl(it.type))
+                }
+
+                ColumnKind.Value -> {
+                    require(!column.hasNulls() || it.type.isMarkedNullable) {
+                        "Can not set `null` in non-nullable property `${it.name}: ${it.type}`"
+                    }
+                    val converted = column.convertTo(it.type)
+                    require(converted.type.withNullability(false).isSubtypeOf(it.type)) {
+                        "Can not convert ${column.type()} to ${it.type} for column `${column.name()}`"
+                    }
+                    converted
+                }
+            }
+        } else {
+            column
+        }
+        convertedColumn
+    }
+
+    return rows().map { row ->
+        val parameters = convertedColumns
+            .map { row[it] }
+            .toTypedArray()
+        constructor.call(*parameters)
+    }
+}
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/update.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/update.kt
new file mode 100644
index 000000000..be27e2761
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/update.kt
@@ -0,0 +1,166 @@
+package org.jetbrains.kotlinx.dataframe.impl.api
+
+import org.jetbrains.kotlinx.dataframe.AnyFrame
+import org.jetbrains.kotlinx.dataframe.AnyRow
+import org.jetbrains.kotlinx.dataframe.ColumnExpression
+import org.jetbrains.kotlinx.dataframe.DataColumn
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.DataFrameExpression
+import org.jetbrains.kotlinx.dataframe.DataRow
+import org.jetbrains.kotlinx.dataframe.RowValueFilter
+import org.jetbrains.kotlinx.dataframe.api.AddDataRow
+import org.jetbrains.kotlinx.dataframe.api.Update
+import org.jetbrains.kotlinx.dataframe.api.asColumnGroup
+import org.jetbrains.kotlinx.dataframe.api.asDataFrame
+import org.jetbrains.kotlinx.dataframe.api.cast
+import org.jetbrains.kotlinx.dataframe.api.indices
+import org.jetbrains.kotlinx.dataframe.api.isEmpty
+import org.jetbrains.kotlinx.dataframe.api.name
+import org.jetbrains.kotlinx.dataframe.api.replace
+import org.jetbrains.kotlinx.dataframe.api.toColumn
+import org.jetbrains.kotlinx.dataframe.api.toDataFrame
+import org.jetbrains.kotlinx.dataframe.api.with
+import org.jetbrains.kotlinx.dataframe.columns.ColumnGroup
+import org.jetbrains.kotlinx.dataframe.columns.FrameColumn
+import org.jetbrains.kotlinx.dataframe.columns.size
+import org.jetbrains.kotlinx.dataframe.impl.columns.AddDataRowImpl
+import org.jetbrains.kotlinx.dataframe.impl.createDataCollector
+import org.jetbrains.kotlinx.dataframe.index
+import org.jetbrains.kotlinx.dataframe.type
+import kotlin.reflect.full.isSubclassOf
+import kotlin.reflect.full.withNullability
+import kotlin.reflect.jvm.jvmErasure
+
+@PublishedApi
+internal fun <T, C> Update<T, C>.updateImpl(expression: (AddDataRow<T>, DataColumn<C>, C) -> C?): DataFrame<T> =
+    if (df.isEmpty()) {
+        df
+    } else {
+        df.replace(columns).with { it.updateImpl(df, filter, expression) }
+    }
+
+internal fun <T, C> Update<T, C>.updateWithValuePerColumnImpl(selector: ColumnExpression<C, C>) =
+    if (df.isEmpty()) {
+        df
+    } else {
+        df.replace(columns).with {
+            val value = selector(it, it)
+            val convertedValue = value?.convertTo(it.type()) as C
+            it.updateImpl(df, filter) { _, _, _ -> convertedValue }
+        }
+    }
+
+/**
+ * Implementation for Update As Frame:
+ * Replaces selected column groups with the result of the expression only where the filter is true.
+ */
+internal fun <T, C, R> Update<T, DataRow<C>>.asFrameImpl(
+    expression: DataFrameExpression<C, DataFrame<R>>,
+): DataFrame<T> =
+    if (df.isEmpty()) {
+        df
+    } else {
+        df.replace(columns).with {
+            // First, we create an updated column group with the result of the expression
+            val srcColumnGroup = it.asColumnGroup()
+            val updatedColumnGroup = srcColumnGroup
+                .asDataFrame()
+                .let { expression(it, it) }
+                .asColumnGroup(srcColumnGroup.name())
+
+            if (filter == null) {
+                // If there is no filter, we simply return the updated column group
+                updatedColumnGroup
+            } else {
+                // If there is a filter, then we replace the rows of the source column group with the updated column group
+                // only if they satisfy the filter
+                srcColumnGroup.replaceRowsIf(from = updatedColumnGroup) {
+                    val srcRow = df[it.index]
+                    val srcValue = srcRow[srcColumnGroup]
+
+                    filter.invoke(srcRow, srcValue)
+                }
+            }
+        }
+    }
+
+private fun <C, R> ColumnGroup<C>.replaceRowsIf(
+    from: ColumnGroup<R>,
+    condition: (DataRow<C>) -> Boolean = { true },
+): ColumnGroup<C> =
+    values()
+        .map { if (condition(it)) from[it.index] else it }
+        .toColumn(name)
+        .asColumnGroup()
+        .cast()
+
+internal fun <T, C> DataColumn<C>.updateImpl(
+    df: DataFrame<T>,
+    filter: RowValueFilter<T, C>?,
+    expression: (AddDataRow<T>, DataColumn<C>, C) -> C?,
+): DataColumn<C> {
+    val collector = createDataCollector<C>(size, type)
+    val src = this
+    if (filter == null) {
+        df.indices().forEach { rowIndex ->
+            val row = AddDataRowImpl(rowIndex, df, collector.values)
+            collector.add(expression(row, src, src[rowIndex]))
+        }
+    } else {
+        df.indices().forEach { rowIndex ->
+            val row = AddDataRowImpl(rowIndex, df, collector.values)
+            val currentValue = row[src]
+            val newValue =
+                if (filter.invoke(row, currentValue)) expression(row, src, currentValue) else currentValue
+            collector.add(newValue)
+        }
+    }
+    return collector.toColumn(src.name).cast()
+}
+
+/**
+ * Replaces all values in column asserting that new values are compatible with current column kind
+ */
+internal fun <T> DataColumn<T>.updateWith(values: List<T>): DataColumn<T> =
+    when (this) {
+        is FrameColumn<*> -> {
+            values.forEach {
+                require(it is AnyFrame) { "Can not add value '$it' to FrameColumn" }
+            }
+            val groups = (values as List<AnyFrame>)
+            DataColumn.createFrameColumn(name, groups) as DataColumn<T>
+        }
+
+        is ColumnGroup<*> -> {
+            this.columns()
+                .mapIndexed { colIndex, col ->
+                    val newValues = values.map {
+                        when (it) {
+                            null -> null
+                            is List<*> -> it[colIndex]
+                            is AnyRow -> it.getOrNull(col.name)
+                            else -> require(false) { "Can not add value '$it' to ColumnGroup" }
+                        }
+                    }
+                    col.updateWith(newValues)
+                }.toDataFrame()
+                .let { DataColumn.createColumnGroup(name, it) } as DataColumn<T>
+        }
+
+        else -> {
+            var nulls = false
+            val kclass = type.jvmErasure
+            values.forEach {
+                when (it) {
+                    null -> nulls = true
+
+                    else -> {
+                        require(it.javaClass.kotlin.isSubclassOf(kclass)) {
+                            "Can not add value '$it' to column '$name' of type $type"
+                        }
+                    }
+                }
+            }
+            DataColumn.createValueColumn(name, values, type.withNullability(nulls))
+        }
+    }
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/xs.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/xs.kt
new file mode 100644
index 000000000..ffb9489fa
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/xs.kt
@@ -0,0 +1,52 @@
+package org.jetbrains.kotlinx.dataframe.impl.api
+
+import org.jetbrains.kotlinx.dataframe.ColumnsSelector
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.api.GroupBy
+import org.jetbrains.kotlinx.dataframe.api.asGroupBy
+import org.jetbrains.kotlinx.dataframe.api.filter
+import org.jetbrains.kotlinx.dataframe.api.toDataFrame
+import org.jetbrains.kotlinx.dataframe.columns.UnresolvedColumnsPolicy
+import org.jetbrains.kotlinx.dataframe.columns.toColumnSet
+import org.jetbrains.kotlinx.dataframe.impl.columns.isMissingColumn
+import org.jetbrains.kotlinx.dataframe.impl.getColumnPaths
+import org.jetbrains.kotlinx.dataframe.impl.getColumnsImpl
+
+internal fun <T, C> DataFrame<T>.xsImpl(
+    keyColumns: ColumnsSelector<T, C>,
+    allowMissingColumns: Boolean,
+    vararg keyValues: C,
+): DataFrame<T> {
+    val cols =
+        getColumnsImpl(
+            unresolvedColumnsPolicy =
+                if (allowMissingColumns) {
+                    UnresolvedColumnsPolicy.Create
+                } else {
+                    UnresolvedColumnsPolicy.Fail
+                },
+            selector = keyColumns,
+        )
+    val n = keyValues.count()
+    require(cols.size == n) { "Number of key values $n doesn't equal to number of key columns ${cols.size}" }
+    val pairs = cols.zip(keyValues).filter { !it.first.isMissingColumn() }
+    return filter {
+        val rowIndex = index()
+        var include = true
+        for ((col, value) in pairs) {
+            if (col[rowIndex] != value) {
+                include = false
+                break
+            }
+        }
+        include
+    }.removeImpl(allowMissingColumns, keyColumns).df
+}
+
+internal fun <T, G, C> GroupBy<T, G>.xsImpl(vararg keyValues: C, keyColumns: ColumnsSelector<T, C>): GroupBy<T, G> {
+    val df = toDataFrame()
+    val paths = df.getColumnPaths(UnresolvedColumnsPolicy.Create, keyColumns).toColumnSet()
+    val d1 = df.xsImpl({ paths }, true, *keyValues).asGroupBy(groups)
+    val d2 = d1.updateGroups { it.xsImpl({ paths }, true, *keyValues) }
+    return d2
+}
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/codeGen/CodeGeneratorImpl.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/codeGen/CodeGeneratorImpl.kt
new file mode 100644
index 000000000..c4f0d5eb4
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/codeGen/CodeGeneratorImpl.kt
@@ -0,0 +1,584 @@
+package org.jetbrains.kotlinx.dataframe.impl.codeGen
+
+import com.squareup.kotlinpoet.buildCodeBlock
+import org.jetbrains.dataframe.impl.codeGen.CodeGenResult
+import org.jetbrains.dataframe.impl.codeGen.CodeGenerator
+import org.jetbrains.dataframe.impl.codeGen.InterfaceGenerationMode
+import org.jetbrains.dataframe.impl.codeGen.InterfaceGenerationMode.Enum
+import org.jetbrains.dataframe.impl.codeGen.InterfaceGenerationMode.NoFields
+import org.jetbrains.dataframe.impl.codeGen.InterfaceGenerationMode.None
+import org.jetbrains.dataframe.impl.codeGen.InterfaceGenerationMode.TypeAlias
+import org.jetbrains.dataframe.impl.codeGen.InterfaceGenerationMode.WithFields
+import org.jetbrains.dataframe.keywords.HardKeywords
+import org.jetbrains.dataframe.keywords.ModifierKeywords
+import org.jetbrains.kotlinx.dataframe.ColumnsContainer
+import org.jetbrains.kotlinx.dataframe.DataColumn
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.DataRow
+import org.jetbrains.kotlinx.dataframe.annotations.DataSchema
+import org.jetbrains.kotlinx.dataframe.api.ColumnSelectionDsl
+import org.jetbrains.kotlinx.dataframe.api.DataSchemaEnum
+import org.jetbrains.kotlinx.dataframe.codeGen.BaseField
+import org.jetbrains.kotlinx.dataframe.codeGen.CodeWithConverter
+import org.jetbrains.kotlinx.dataframe.codeGen.DefaultReadDfMethod
+import org.jetbrains.kotlinx.dataframe.codeGen.ExtensionsCodeGenerator
+import org.jetbrains.kotlinx.dataframe.codeGen.FieldType
+import org.jetbrains.kotlinx.dataframe.codeGen.IsolatedMarker
+import org.jetbrains.kotlinx.dataframe.codeGen.Marker
+import org.jetbrains.kotlinx.dataframe.codeGen.MarkerVisibility
+import org.jetbrains.kotlinx.dataframe.codeGen.NameNormalizer
+import org.jetbrains.kotlinx.dataframe.codeGen.SchemaProcessor
+import org.jetbrains.kotlinx.dataframe.codeGen.ValidFieldName
+import org.jetbrains.kotlinx.dataframe.codeGen.toNullable
+import org.jetbrains.kotlinx.dataframe.columns.ColumnGroup
+import org.jetbrains.kotlinx.dataframe.impl.toSnakeCase
+import org.jetbrains.kotlinx.dataframe.schema.DataFrameSchema
+import org.jetbrains.kotlinx.jupyter.api.Code
+
+private fun renderNullability(nullable: Boolean) = if (nullable) "?" else ""
+
+internal fun Iterable<Marker>.filterRequiredForSchema(schema: DataFrameSchema) =
+    filter { it.isOpen && it.schema.compare(schema).isSuperOrEqual() }
+
+internal val charsToQuote = """[ `(){}\[\].<>'"/|\\!?@:;%^&*#$-]""".toRegex()
+
+internal fun createCodeWithConverter(code: String, markerName: String) =
+    CodeWithConverter(code) { "$it.cast<$markerName>()" }
+
+private val letterCategories = setOf(
+    CharCategory.UPPERCASE_LETTER,
+    CharCategory.TITLECASE_LETTER,
+    CharCategory.MODIFIER_LETTER,
+    CharCategory.LOWERCASE_LETTER,
+    CharCategory.DECIMAL_DIGIT_NUMBER,
+)
+
+internal fun String.needsQuoting(): Boolean =
+    if (isQuoted()) {
+        false
+    } else {
+        isBlank() ||
+            first().isDigit() ||
+            contains(charsToQuote) ||
+            HardKeywords.VALUES.contains(this) ||
+            ModifierKeywords.VALUES.contains(this) ||
+            all { it == '_' } ||
+            any { it != '_' && it.category !in letterCategories }
+    }
+
+public fun String.isQuoted(): Boolean = startsWith("`") && endsWith("`")
+
+public fun String.quoteIfNeeded(): String = if (needsQuoting()) "`$this`" else this
+
+internal fun List<Code>.join() = joinToString("\n")
+
+/** Strategy to render types. Instances include [FullyQualifiedNames] and [ShortNames]. */
+internal interface TypeRenderingStrategy {
+
+    /**
+     * How to render a row type. Used as receiver type for column accessors for DSLs.
+     * E.g.: `DataRow<Marker>`
+     */
+    fun renderRowTypeName(markerName: String): String
+
+    /**
+     * How to render a columns-container (base type for [DataFrame] and [ColumnSelectionDsl]).
+     * Used as receiver type for column accessors.
+     * E.g.: `ColumnsContainer<Marker>`
+     */
+    fun renderColumnsContainerTypeName(markerName: String): String
+
+    /**
+     * How to render a column type from a [BaseField]. Used as return type for column accessors.
+     * Result will be a [DataColumn] (or [ColumnGroup], which can be seen as a [DataColumn]).
+     * E.g.: `DataColumn<DataFrame<Marker>>`
+     */
+    fun BaseField.renderColumnType(): Code
+
+    /**
+     * How to render the field type of [BaseField]. Used as return type for column accessors for DSLs.
+     * Result will be either the value type name, a [DataRow] or [DataFrame].
+     */
+    fun BaseField.renderAccessorFieldType(): Code
+
+    /**
+     * How to render the field type of [BaseField]. Used as property type in generated interfaces.
+     * Result will be either the value type name, the group field type name or [DataFrame].
+     */
+    fun BaseField.renderFieldType(): Code
+}
+
+internal object FullyQualifiedNames : TypeRenderingStrategy {
+
+    private val dataRow = DataRow::class.qualifiedName!!
+    private val columnsContainer = ColumnsContainer::class.qualifiedName!!
+    private val dataFrame = DataFrame::class.qualifiedName!!
+    private val dataColumn = DataColumn::class.qualifiedName!!
+    private val columnGroup = ColumnGroup::class.qualifiedName!!
+
+    override fun renderRowTypeName(markerName: String) = "$dataRow<$markerName>"
+
+    override fun renderColumnsContainerTypeName(markerName: String) = "$columnsContainer<$markerName>"
+
+    override fun BaseField.renderColumnType(): Code =
+        when (val fieldType = fieldType) {
+            is FieldType.ValueFieldType ->
+                "$dataColumn<${fieldType.typeFqName}>"
+
+            is FieldType.GroupFieldType ->
+                "$columnGroup<${fieldType.markerName}>"
+
+            is FieldType.FrameFieldType ->
+                "$dataColumn<$dataFrame<${fieldType.markerName}>${renderNullability(fieldType.nullable)}>"
+        }
+
+    override fun BaseField.renderAccessorFieldType(): Code =
+        when (val fieldType = fieldType) {
+            is FieldType.ValueFieldType ->
+                fieldType.typeFqName
+
+            is FieldType.GroupFieldType ->
+                "$dataRow<${fieldType.markerName}>"
+
+            is FieldType.FrameFieldType ->
+                "$dataFrame<${fieldType.markerName}>${renderNullability(fieldType.nullable)}"
+        }
+
+    override fun BaseField.renderFieldType(): Code =
+        when (val fieldType = fieldType) {
+            is FieldType.ValueFieldType ->
+                fieldType.typeFqName
+
+            is FieldType.GroupFieldType -> if (fieldType.renderAsObject) {
+                fieldType.markerName
+            } else {
+                renderAccessorFieldType()
+            }
+
+            is FieldType.FrameFieldType -> if (fieldType.renderAsList) {
+                "List<${fieldType.markerName}>${renderNullability(fieldType.nullable)}"
+            } else {
+                renderAccessorFieldType()
+            }
+        }
+}
+
+internal object ShortNames : TypeRenderingStrategy {
+
+    private val dataRow = DataRow::class.simpleName!!
+    private val columnsContainer = ColumnsContainer::class.simpleName!!
+    private val dataFrame = DataFrame::class.simpleName!!
+    private val dataColumn = DataColumn::class.simpleName!!
+    private val columnGroup = ColumnGroup::class.simpleName!!
+
+    override fun renderRowTypeName(markerName: String): String = "$dataRow<${markerName.shorten()}>"
+
+    override fun renderColumnsContainerTypeName(markerName: String): String =
+        "$columnsContainer<${markerName.shorten()}>"
+
+    override fun BaseField.renderColumnType(): Code =
+        when (val fieldType = fieldType) {
+            is FieldType.ValueFieldType ->
+                "$dataColumn<${fieldType.typeFqName.shorten()}>"
+
+            is FieldType.GroupFieldType ->
+                "$columnGroup<${fieldType.markerName}>"
+
+            is FieldType.FrameFieldType ->
+                "$dataColumn<$dataFrame<${fieldType.markerName}>${renderNullability(fieldType.nullable)}>"
+        }
+
+    override fun BaseField.renderAccessorFieldType(): Code =
+        when (val fieldType = fieldType) {
+            is FieldType.ValueFieldType ->
+                fieldType.typeFqName.shorten()
+
+            is FieldType.GroupFieldType ->
+                "$dataRow<${fieldType.markerName}>"
+
+            is FieldType.FrameFieldType ->
+                "$dataFrame<${fieldType.markerName}>${renderNullability(fieldType.nullable)}"
+        }
+
+    override fun BaseField.renderFieldType(): Code =
+        when (val fieldType = fieldType) {
+            is FieldType.ValueFieldType ->
+                fieldType.typeFqName.shorten()
+
+            is FieldType.GroupFieldType -> if (fieldType.renderAsObject) {
+                fieldType.markerName
+            } else {
+                renderAccessorFieldType()
+            }
+
+            is FieldType.FrameFieldType -> if (fieldType.renderAsList) {
+                "List<${fieldType.markerName}>${renderNullability(fieldType.nullable)}"
+            } else {
+                renderAccessorFieldType()
+            }
+        }
+
+    private fun String.shorten() = removeRedundantQualifier(this)
+
+    private fun removeRedundantQualifier(markerName: String): String {
+        val parts = markerName.split('.')
+        return if (parts.size == 2 && parts[0] == "kotlin") {
+            parts[1]
+        } else {
+            markerName
+        }
+    }
+}
+
+internal open class ExtensionsCodeGeneratorImpl(private val typeRendering: TypeRenderingStrategy) :
+    ExtensionsCodeGenerator,
+    TypeRenderingStrategy by typeRendering {
+
+    fun renderStringLiteral(name: String) =
+        name
+            .replace("\\", "\\\\")
+            .replace("$", "\\\$")
+            .replace("\"", "\\\"")
+
+    private fun String.removeQuotes() = this.removeSurrounding("`")
+
+    private fun generatePropertyCode(
+        marker: IsolatedMarker,
+        shortMarkerName: String,
+        typeName: String,
+        name: String,
+        propertyType: String,
+        getter: String,
+        visibility: String,
+    ): String {
+        // jvm name is required to prevent signature clash like this:
+        // val DataRow<Type>.name: String
+        // val DataRow<Repo>.name: String
+        val jvmName = "${shortMarkerName}_${name.removeQuotes()}"
+        val typeParameters = marker.typeParameters.let {
+            if (it.isNotEmpty() && !it.startsWith(" ")) {
+                " $it"
+            } else {
+                it
+            }
+        }
+        return "${visibility}val$typeParameters $typeName.$name: $propertyType @JvmName(\"${
+            renderStringLiteral(jvmName)
+        }\") get() = $getter as $propertyType"
+    }
+
+    /**
+     * nullable properties can be needed when *DECLARED* schema is referenced with nullability:
+     * ```
+     * @DataSchema
+     * data class Schema(val i: Int)
+     *
+     * @DataSchema
+     * data class A(
+     *  val prop: Schema?
+     * )
+     * ```
+     * When converted `listOf<A>().toDataFrame(maxDepth=2)` actual schema is
+     * ```
+     * prop:
+     *     i: Int?
+     * ```
+     * So this sudden `i: Int?` must be somehow handled.
+     * However, REPL code generator will not create such a situation. Nullable properties are not needed then
+     */
+    protected fun generateExtensionProperties(marker: IsolatedMarker, withNullable: Boolean = true): Code {
+        val markerName = marker.name
+        val markerType = "$markerName${marker.typeArguments}"
+        val visibility = renderTopLevelDeclarationVisibility(marker)
+        val shortMarkerName = markerName.substring(markerName.lastIndexOf('.') + 1).removeQuotes()
+        val nullableShortMarkerName = "Nullable$shortMarkerName"
+
+        fun String.toNullable() = if (this.last() == '?' || this == "*") this else "$this?"
+
+        val declarations = mutableListOf<String>()
+        val dfTypename = renderColumnsContainerTypeName(markerType)
+        val nullableDfTypename = renderColumnsContainerTypeName(markerType.toNullable())
+        val rowTypename = renderRowTypeName(markerType)
+        val nullableRowTypename = renderRowTypeName(markerType.toNullable())
+
+        val nullableFields = marker.fields.map {
+            it.toNullable()
+        }.associateBy { it.columnName }
+
+        marker.fields.sortedBy { it.fieldName.quotedIfNeeded }.forEach {
+            val getter = "this[\"${renderStringLiteral(it.columnName)}\"]"
+            val name = it.fieldName
+            val fieldType = it.renderAccessorFieldType()
+            val nullableFieldType = nullableFields[it.columnName]!!.renderAccessorFieldType()
+            val columnType = it.renderColumnType()
+            val nullableColumnType = nullableFields[it.columnName]!!.renderColumnType()
+
+            declarations.addAll(
+                listOf(
+                    generatePropertyCode(
+                        marker = marker,
+                        shortMarkerName = shortMarkerName,
+                        typeName = dfTypename,
+                        name = name.quotedIfNeeded,
+                        propertyType = columnType,
+                        getter = getter,
+                        visibility = visibility,
+                    ),
+                    generatePropertyCode(
+                        marker = marker,
+                        shortMarkerName = shortMarkerName,
+                        typeName = rowTypename,
+                        name = name.quotedIfNeeded,
+                        propertyType = fieldType,
+                        getter = getter,
+                        visibility = visibility,
+                    ),
+                ),
+            )
+            if (withNullable) {
+                declarations.addAll(
+                    listOf(
+                        generatePropertyCode(
+                            marker = marker,
+                            shortMarkerName = nullableShortMarkerName,
+                            typeName = nullableDfTypename,
+                            name = name.quotedIfNeeded,
+                            propertyType = nullableColumnType,
+                            getter = getter,
+                            visibility = visibility,
+                        ),
+                        generatePropertyCode(
+                            marker = marker,
+                            shortMarkerName = nullableShortMarkerName,
+                            typeName = nullableRowTypename,
+                            name = name.quotedIfNeeded,
+                            propertyType = nullableFieldType,
+                            getter = getter,
+                            visibility = visibility,
+                        ),
+                    ),
+                )
+            }
+        }
+        return declarations.joinToString("\n")
+    }
+
+    override fun generate(marker: IsolatedMarker): CodeWithConverter {
+        val code = generateExtensionProperties(marker)
+        return createCodeWithConverter(code, marker.name)
+    }
+
+    protected fun renderTopLevelDeclarationVisibility(marker: IsolatedMarker) =
+        when (marker.visibility) {
+            MarkerVisibility.INTERNAL -> "internal "
+            MarkerVisibility.IMPLICIT_PUBLIC -> ""
+            MarkerVisibility.EXPLICIT_PUBLIC -> "public "
+        }
+
+    protected fun renderInternalDeclarationVisibility(marker: IsolatedMarker) =
+        when (marker.visibility) {
+            MarkerVisibility.INTERNAL -> ""
+            MarkerVisibility.IMPLICIT_PUBLIC -> ""
+            MarkerVisibility.EXPLICIT_PUBLIC -> "public "
+        }
+}
+
+internal class CodeGeneratorImpl(typeRendering: TypeRenderingStrategy = FullyQualifiedNames) :
+    ExtensionsCodeGeneratorImpl(typeRendering),
+    CodeGenerator {
+    override fun generate(
+        marker: Marker,
+        interfaceMode: InterfaceGenerationMode,
+        extensionProperties: Boolean,
+        readDfMethod: DefaultReadDfMethod?,
+    ): CodeWithConverter {
+        val code = when (interfaceMode) {
+            NoFields, WithFields ->
+                generateInterface(
+                    marker = marker,
+                    fields = interfaceMode == WithFields,
+                    readDfMethod = readDfMethod,
+                ) + if (extensionProperties) "\n" + generateExtensionProperties(marker) else ""
+
+            Enum -> generateEnum(marker)
+
+            TypeAlias -> generateTypeAlias(marker)
+
+            None -> if (extensionProperties) generateExtensionProperties(marker) else ""
+        }
+
+        return createCodeWithConverter(code, marker.name)
+    }
+
+    private fun generateTypeAlias(marker: Marker): Code {
+        val visibility = renderTopLevelDeclarationVisibility(marker)
+
+        return "${visibility}typealias ${marker.name} = ${marker.superMarkers.keys.single()}"
+    }
+
+    private fun generateEnum(marker: Marker): Code {
+        val visibility = renderTopLevelDeclarationVisibility(marker)
+
+        val header =
+            "${visibility}enum class ${marker.name}(override val value: ${String::class.qualifiedName}) : ${DataSchemaEnum::class.qualifiedName}"
+
+        val fieldNames = mutableSetOf<String>()
+        val fieldsDeclaration = marker.fields.mapIndexed { i, it ->
+            val originalFieldName = it.fieldName.unquoted.toSnakeCase().uppercase().ifEmpty { "EMPTY_STRING" }
+            var fieldName = originalFieldName
+            var j = 1
+            while (fieldName in fieldNames) {
+                fieldName = "${originalFieldName}_${j++}"
+            }
+            fieldNames += fieldName
+
+            val valueName = it.fieldName.unquoted
+            val isLast = i == marker.fields.size - 1
+
+            "    ${ValidFieldName.of(fieldName).quotedIfNeeded}(\"$valueName\")${if (isLast) ";" else ","}"
+        }.join()
+
+        val body = if (fieldsDeclaration.isNotBlank()) {
+            buildString {
+                append(" {\n")
+                append(fieldsDeclaration)
+                append("\n}")
+            }
+        } else {
+            ""
+        }
+
+        return listOf(header + body).join()
+    }
+
+    override fun generate(
+        schema: DataFrameSchema,
+        name: String,
+        fields: Boolean,
+        extensionProperties: Boolean,
+        isOpen: Boolean,
+        visibility: MarkerVisibility,
+        knownMarkers: Iterable<Marker>,
+        readDfMethod: DefaultReadDfMethod?,
+        fieldNameNormalizer: NameNormalizer,
+        asDataClass: Boolean,
+    ): CodeGenResult {
+        val context = SchemaProcessor.create(name, if (asDataClass) emptyList() else knownMarkers, fieldNameNormalizer)
+        val marker = context.process(schema, isOpen, visibility)
+        val declarations = mutableListOf<Code>()
+        context.generatedMarkers.forEach { itMarker ->
+            val declaration = if (asDataClass) {
+                generateClasses(itMarker)
+            } else {
+                generateInterface(itMarker, fields, readDfMethod.takeIf { marker == itMarker })
+            }
+            declarations.add(declaration)
+            if (extensionProperties) {
+                declarations.add(generateExtensionProperties(itMarker, withNullable = false))
+            }
+        }
+        val code = createCodeWithConverter(declarations.joinToString("\n\n"), marker.name)
+        return CodeGenResult(code, context.generatedMarkers)
+    }
+
+    private fun generateInterface(marker: Marker, fields: Boolean, readDfMethod: DefaultReadDfMethod? = null): Code {
+        val annotationName = DataSchema::class.simpleName
+
+        val visibility = renderTopLevelDeclarationVisibility(marker)
+        val propertyVisibility = renderInternalDeclarationVisibility(marker)
+
+        val header =
+            "@$annotationName${if (marker.isOpen) "" else "(isOpen = false)"}\n${visibility}interface ${marker.name}"
+        val baseInterfacesDeclaration =
+            if (marker.superMarkers.isNotEmpty()) {
+                " : " + marker.superMarkers
+                    .map { it.value.name + it.value.typeArguments }
+                    .joinToString()
+            } else {
+                ""
+            }
+        val resultDeclarations = mutableListOf<String>()
+
+        val fieldsDeclaration = if (fields) renderFields(marker, propertyVisibility).join() else ""
+
+        val readDfMethodDeclaration = readDfMethod?.toDeclaration(marker, propertyVisibility)
+
+        val body = if (fieldsDeclaration.isNotBlank() || readDfMethodDeclaration?.isNotBlank() == true) {
+            buildString {
+                append(" {\n")
+                append(fieldsDeclaration)
+                if (readDfMethodDeclaration != null) {
+                    append("\n")
+                    val companionObject = buildCodeBlock {
+                        add("    ")
+                        indent()
+                        indent()
+                        add(readDfMethodDeclaration)
+                    }
+                    append(companionObject.toString())
+                }
+                append("\n}")
+            }
+        } else {
+            " { }"
+        }
+        resultDeclarations.add(header + baseInterfacesDeclaration + body)
+        return resultDeclarations.join()
+    }
+
+    private fun generateClasses(marker: Marker): Code {
+        val annotationName = DataSchema::class.simpleName
+
+        val visibility = renderTopLevelDeclarationVisibility(marker)
+        val propertyVisibility = renderInternalDeclarationVisibility(marker)
+        val header =
+            "@$annotationName\n${visibility}data class ${marker.name}("
+
+        val fieldsDeclaration = renderFields(marker, propertyVisibility).joinToString(",\n")
+        return buildString {
+            appendLine(header)
+            appendLine(fieldsDeclaration)
+            append(")")
+        }
+    }
+
+    private fun renderFields(marker: Marker, propertyVisibility: String): List<String> =
+        marker.fields.map {
+            val override = if (it.overrides) "override " else ""
+            val columnNameAnnotation = if (it.columnName != it.fieldName.quotedIfNeeded) {
+                "    @ColumnName(\"${renderStringLiteral(it.columnName)}\")\n"
+            } else {
+                ""
+            }
+
+            val fieldType = it.renderFieldType()
+            "$columnNameAnnotation    ${propertyVisibility}${override}val ${it.fieldName.quotedIfNeeded}: $fieldType"
+        }
+}
+
+public fun CodeWithConverter.toStandaloneSnippet(packageName: String, additionalImports: List<String>): String =
+    declarations.toStandaloneSnippet(packageName, additionalImports)
+
+public fun Code.toStandaloneSnippet(packageName: String, additionalImports: List<String>): String =
+    buildString {
+        if (packageName.isNotEmpty()) {
+            appendLine("package $packageName")
+            appendLine()
+        }
+        appendLine("import org.jetbrains.kotlinx.dataframe.ColumnsContainer")
+        appendLine("import org.jetbrains.kotlinx.dataframe.DataColumn")
+        appendLine("import org.jetbrains.kotlinx.dataframe.DataFrame")
+        appendLine("import org.jetbrains.kotlinx.dataframe.DataRow")
+        appendLine("import org.jetbrains.kotlinx.dataframe.columns.ColumnGroup")
+        appendLine("import org.jetbrains.kotlinx.dataframe.annotations.ColumnName")
+        appendLine("import org.jetbrains.kotlinx.dataframe.annotations.DataSchema")
+        appendLine("import org.jetbrains.kotlinx.dataframe.api.cast")
+        additionalImports.forEach {
+            appendLine(it)
+        }
+        appendLine()
+        appendLine(this@toStandaloneSnippet)
+    }
+
+public fun CodeGenResult.toStandaloneSnippet(packageName: String, additionalImports: List<String>): String =
+    code.toStandaloneSnippet(packageName, additionalImports)
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/codeGen/NameNormalizerImpl.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/codeGen/NameNormalizerImpl.kt
new file mode 100644
index 000000000..d09a00144
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/codeGen/NameNormalizerImpl.kt
@@ -0,0 +1,25 @@
+package org.jetbrains.kotlinx.dataframe.impl.codeGen
+
+import org.jetbrains.kotlinx.dataframe.codeGen.NameNormalizer
+import org.jetbrains.kotlinx.dataframe.impl.toCamelCaseByDelimiters
+import java.util.Locale
+
+public fun NameNormalizer.Companion.from(normalizationDelimiters: Set<Char>): NameNormalizer {
+    val delimitersSet = normalizationDelimiters.joinToString("", "[", "]")
+    val delimitedStringRegex by lazy {
+        ".+$delimitersSet.+".toRegex()
+    }
+    return NameNormalizer {
+        when {
+            normalizationDelimiters.isEmpty() -> it
+
+            it matches delimitedStringRegex -> {
+                it.lowercase(Locale.getDefault()).toCamelCaseByDelimiters(delimitersSet.toRegex())
+            }
+
+            else -> it
+        }
+    }
+}
+
+public fun NameNormalizer.Companion.id(): NameNormalizer = NameNormalizer { it }
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/codeGen/ReplCodeGeneratorImpl.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/codeGen/ReplCodeGeneratorImpl.kt
new file mode 100644
index 000000000..7990ab01c
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/codeGen/ReplCodeGeneratorImpl.kt
@@ -0,0 +1,140 @@
+package org.jetbrains.kotlinx.dataframe.impl.codeGen
+
+import org.jetbrains.dataframe.impl.codeGen.CodeGenerator
+import org.jetbrains.dataframe.impl.codeGen.InterfaceGenerationMode
+import org.jetbrains.dataframe.impl.codeGen.ReplCodeGenerator
+import org.jetbrains.kotlinx.dataframe.AnyFrame
+import org.jetbrains.kotlinx.dataframe.AnyRow
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.DataRow
+import org.jetbrains.kotlinx.dataframe.annotations.DataSchema
+import org.jetbrains.kotlinx.dataframe.api.schema
+import org.jetbrains.kotlinx.dataframe.codeGen.CodeWithConverter
+import org.jetbrains.kotlinx.dataframe.codeGen.Marker
+import org.jetbrains.kotlinx.dataframe.codeGen.MarkerVisibility
+import org.jetbrains.kotlinx.dataframe.codeGen.MarkersExtractor
+import org.jetbrains.kotlinx.dataframe.schema.DataFrameSchema
+import org.jetbrains.kotlinx.jupyter.api.Code
+import kotlin.reflect.KClass
+import kotlin.reflect.KProperty
+import kotlin.reflect.KType
+import kotlin.reflect.KVisibility
+import kotlin.reflect.full.findAnnotation
+import kotlin.reflect.full.superclasses
+import kotlin.reflect.jvm.jvmErasure
+
+internal class ReplCodeGeneratorImpl : ReplCodeGenerator {
+
+    companion object {
+        internal val markerInterfacePrefix = "_DataFrameType"
+    }
+
+    private val registeredProperties = mutableSetOf<KProperty<*>>()
+
+    private val registeredMarkers = mutableMapOf<KClass<*>, Marker>()
+
+    private val generatedMarkers = mutableMapOf<String, Marker>()
+
+    private val generator: CodeGenerator = CodeGenerator.create(useFqNames = false)
+
+    private fun getMarkerClass(type: KType): KClass<*>? =
+        when (type.classifier) {
+            DataFrame::class -> type.arguments[0].type?.jvmErasure
+            DataRow::class -> type.arguments[0].type?.jvmErasure
+            else -> null
+        }
+
+    override fun process(row: AnyRow, property: KProperty<*>?): CodeWithConverter = process(row.df(), property)
+
+    override fun process(df: AnyFrame, property: KProperty<*>?): CodeWithConverter {
+        var targetSchema = df.schema()
+
+        if (property != null) {
+            val wasProcessedBefore = property in registeredProperties
+            registeredProperties.add(property)
+
+            // maybe property is already properly typed, let's do some checks
+            val currentMarker = getMarkerClass(property.returnType)
+                ?.takeIf { it.findAnnotation<DataSchema>() != null }
+                ?.let { registeredMarkers[it] ?: MarkersExtractor.get(it) }
+            if (currentMarker != null) {
+                // we need to make sure that the property's marker type is open in order to let derived data frames be assignable to it
+                if (currentMarker.isOpen) {
+                    val columnSchema = currentMarker.schema
+                    // for mutable properties we do strong typing only at the first processing, after that we allow its type to be more general than actual data frame type
+                    if (wasProcessedBefore || columnSchema == targetSchema) {
+                        // property scheme is valid for current data frame, but we should also check that all compatible open markers are implemented by it
+                        val requiredBaseMarkers = registeredMarkers.values.filterRequiredForSchema(columnSchema)
+                        if (requiredBaseMarkers.any() && requiredBaseMarkers.all { currentMarker.implements(it) }) {
+                            return CodeWithConverter.EMPTY
+                        }
+                        // use current marker scheme as a target for generation of new marker interface, so that available properties won't change
+                        targetSchema = columnSchema
+                    }
+                }
+            }
+        }
+
+        return generate(schema = targetSchema, name = markerInterfacePrefix, isOpen = true)
+    }
+
+    fun generate(schema: DataFrameSchema, name: String, isOpen: Boolean): CodeWithConverter {
+        val result = generator.generate(
+            schema = schema,
+            name = name,
+            fields = false,
+            extensionProperties = true,
+            isOpen = isOpen,
+            visibility = MarkerVisibility.IMPLICIT_PUBLIC,
+            knownMarkers = registeredMarkers
+                .filterKeys { it.visibility != KVisibility.PRIVATE }
+                .values,
+        )
+
+        result.newMarkers.forEach {
+            generatedMarkers[it.name] = it
+        }
+        return result.code
+    }
+
+    override fun process(markerClass: KClass<*>): Code {
+        val newMarkers = mutableListOf<Marker>()
+
+        fun resolve(clazz: KClass<*>): Marker {
+            val processed = registeredMarkers[clazz]
+            if (processed != null) return processed
+            val temp = generatedMarkers[clazz.simpleName!!]
+            if (temp != null) {
+                val baseClasses = clazz.superclasses.filter { it != Any::class }
+
+                val baseClassNames = baseClasses
+                    .map { it.simpleName!! }
+                    .sorted()
+
+                val tempBaseClassNames = temp.superMarkers.map { it.value.shortName }.sorted()
+
+                if (baseClassNames == tempBaseClassNames) {
+                    val newBaseMarkers = baseClasses.map { resolve(it) }
+                    val newMarker = Marker(
+                        name = clazz.qualifiedName!!,
+                        isOpen = temp.isOpen,
+                        fields = temp.fields,
+                        superMarkers = newBaseMarkers,
+                        visibility = MarkerVisibility.IMPLICIT_PUBLIC,
+                        klass = clazz,
+                    )
+                    registeredMarkers[markerClass] = newMarker
+                    generatedMarkers.remove(temp.name)
+                    return newMarker
+                }
+            }
+            val marker = MarkersExtractor.get(markerClass)
+            registeredMarkers[markerClass] = marker
+            newMarkers.add(marker)
+            return marker
+        }
+
+        val marker = resolve(markerClass)
+        return newMarkers.map { generator.generate(marker, InterfaceGenerationMode.None, true).declarations }.join()
+    }
+}
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/codeGen/SchemaProcessorImpl.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/codeGen/SchemaProcessorImpl.kt
new file mode 100644
index 000000000..9517fbe07
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/codeGen/SchemaProcessorImpl.kt
@@ -0,0 +1,174 @@
+package org.jetbrains.kotlinx.dataframe.impl.codeGen
+
+import org.jetbrains.kotlinx.dataframe.codeGen.FieldType
+import org.jetbrains.kotlinx.dataframe.codeGen.GeneratedField
+import org.jetbrains.kotlinx.dataframe.codeGen.Marker
+import org.jetbrains.kotlinx.dataframe.codeGen.MarkerVisibility
+import org.jetbrains.kotlinx.dataframe.codeGen.SchemaProcessor
+import org.jetbrains.kotlinx.dataframe.codeGen.ValidFieldName
+import org.jetbrains.kotlinx.dataframe.schema.ColumnSchema
+import org.jetbrains.kotlinx.dataframe.schema.DataFrameSchema
+
+internal class SchemaProcessorImpl(
+    existingMarkers: Iterable<Marker>,
+    override val namePrefix: String,
+    private val fieldNameNormalizer: (String) -> String = { it },
+) : SchemaProcessor {
+
+    private val registeredMarkers = existingMarkers.toMutableList()
+
+    private val usedMarkerNames = existingMarkers.map { it.shortName }.toMutableSet()
+
+    override val generatedMarkers = mutableListOf<Marker>()
+
+    private fun DataFrameSchema.getAllSuperMarkers() =
+        registeredMarkers
+            .filter { it.isOpen && it.schema.compare(this).isSuperOrEqual() }
+
+    private fun List<Marker>.onlyLeafs(): List<Marker> {
+        val skip = flatMap { it.allSuperMarkers.keys }.toSet()
+        return filter { !skip.contains(it.name) }
+    }
+
+    private fun generateValidFieldName(columnName: String, index: Int, usedNames: Collection<String>): ValidFieldName {
+        var result = ValidFieldName.of(columnName)
+        result = ValidFieldName.of(fieldNameNormalizer(result.unquoted))
+        if (result.unquoted.isEmpty()) result = ValidFieldName.of("_$index")
+        val baseName = result
+        var attempt = 2
+        while (usedNames.contains(result.quotedIfNeeded)) {
+            result =
+                if (result.needsQuote) {
+                    baseName + ValidFieldName.of(" ($attempt)")
+                } else {
+                    baseName + ValidFieldName.of("$attempt")
+                }
+            attempt++
+        }
+        return result
+    }
+
+    private fun generateUniqueMarkerClassName(prefix: String): String {
+        if (!usedMarkerNames.contains(prefix)) return prefix
+        var id = 1
+        while (usedMarkerNames.contains("$prefix$id")) id++
+        return "$prefix$id"
+    }
+
+    private fun generateFields(
+        schema: DataFrameSchema,
+        visibility: MarkerVisibility,
+        requiredSuperMarkers: List<Marker> = emptyList(),
+    ): List<GeneratedField> {
+        val usedFieldNames =
+            requiredSuperMarkers.flatMap { it.allFields.map { it.fieldName.quotedIfNeeded } }.toMutableSet()
+
+        fun getFieldType(columnSchema: ColumnSchema): FieldType =
+            when (columnSchema) {
+                is ColumnSchema.Value ->
+                    FieldType.ValueFieldType(columnSchema.type.toString())
+
+                is ColumnSchema.Group ->
+                    FieldType.GroupFieldType(
+                        process(columnSchema.schema, false, visibility).name,
+                        renderAsObject = true,
+                    )
+
+                is ColumnSchema.Frame ->
+                    FieldType.FrameFieldType(
+                        process(columnSchema.schema, false, visibility).name,
+                        columnSchema.nullable,
+                        renderAsList = true,
+                    )
+
+                else -> throw NotImplementedError()
+            }
+
+        return schema.columns.asIterable().sortedBy { it.key }.flatMapIndexed { index, column ->
+            val (columnName, columnSchema) = column
+            val fieldType = getFieldType(columnSchema)
+            // find all fields that were already generated for this column name in base interfaces
+            val superFields = requiredSuperMarkers.mapNotNull { it.getField(columnName) }
+
+            val fieldsToOverride = superFields
+                .filter { it.columnSchema != columnSchema }
+                .map { it.fieldName }
+                .distinctBy { it.unquoted }
+
+            val newFields = when {
+                fieldsToOverride.isNotEmpty() -> fieldsToOverride.map {
+                    GeneratedField(it, columnName, true, columnSchema, fieldType)
+                }
+
+                superFields.isNotEmpty() -> emptyList()
+
+                else -> {
+                    val fieldName = generateValidFieldName(columnName, index, usedFieldNames)
+                    usedFieldNames.add(fieldName.quotedIfNeeded)
+                    listOf(GeneratedField(fieldName, columnName, false, columnSchema, fieldType))
+                }
+            }
+            newFields
+        }
+    }
+
+    private fun createMarkerSchema(
+        scheme: DataFrameSchema,
+        name: String,
+        withBaseInterfaces: Boolean,
+        isOpen: Boolean,
+        visibility: MarkerVisibility,
+    ): Marker {
+        val baseMarkers = mutableListOf<Marker>()
+        val fields = if (withBaseInterfaces) {
+            baseMarkers += scheme.getRequiredMarkers().onlyLeafs()
+
+            val columnNames = scheme.columns.keys
+            val superColumns = baseMarkers.flatMap { it.allFields.map { it.columnName } }.toSet()
+
+            val newColumns = (columnNames - superColumns).toMutableSet()
+
+            if (newColumns.isNotEmpty()) {
+                val availableMarkers = scheme.getAllSuperMarkers().toMutableList()
+                availableMarkers -= baseMarkers.toSet()
+
+                while (newColumns.size > 0) {
+                    val bestMarker = availableMarkers
+                        .map { marker -> marker to newColumns.count { marker.containsColumn(it) } }
+                        .maxByOrNull { it.second }
+                    if (bestMarker != null && bestMarker.second > 0) {
+                        newColumns.removeAll(bestMarker.first.columnNames.toSet())
+                        baseMarkers += bestMarker.first
+                        availableMarkers -= bestMarker.first
+                    } else {
+                        break
+                    }
+                }
+            }
+            generateFields(scheme, visibility, baseMarkers)
+        } else {
+            generateFields(scheme, visibility)
+        }
+        return Marker(name, isOpen, fields, baseMarkers.onlyLeafs(), visibility, emptyList(), emptyList())
+    }
+
+    private fun DataFrameSchema.getRequiredMarkers() = registeredMarkers.filterRequiredForSchema(this)
+
+    override fun process(schema: DataFrameSchema, isOpen: Boolean, visibility: MarkerVisibility): Marker {
+        val markerName: String
+        val required = schema.getRequiredMarkers()
+        val existingMarker = registeredMarkers.firstOrNull {
+            (!isOpen || it.isOpen) && it.schema == schema && it.implementsAll(required)
+        }
+        if (existingMarker != null) {
+            return existingMarker
+        } else {
+            markerName = generateUniqueMarkerClassName(namePrefix)
+            usedMarkerNames.add(markerName)
+            val marker = createMarkerSchema(schema, markerName, true, isOpen, visibility)
+            registeredMarkers.add(marker)
+            generatedMarkers.add(marker)
+            return marker
+        }
+    }
+}
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/codeGen/SchemaReader.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/codeGen/SchemaReader.kt
new file mode 100644
index 000000000..aefc3d8bb
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/codeGen/SchemaReader.kt
@@ -0,0 +1,87 @@
+package org.jetbrains.kotlinx.dataframe.impl.codeGen
+
+import org.jetbrains.dataframe.impl.codeGen.CodeGenerator
+import org.jetbrains.kotlinx.dataframe.AnyFrame
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.api.schema
+import org.jetbrains.kotlinx.dataframe.codeGen.DefaultReadDfMethod
+import org.jetbrains.kotlinx.dataframe.io.SupportedCodeGenerationFormat
+import org.jetbrains.kotlinx.dataframe.io.SupportedDataFrameFormat
+import org.jetbrains.kotlinx.dataframe.io.SupportedFormat
+import org.jetbrains.kotlinx.dataframe.io.guessFormat
+import org.jetbrains.kotlinx.dataframe.io.read
+import org.jetbrains.kotlinx.dataframe.io.readCodeForGeneration
+import org.jetbrains.kotlinx.dataframe.schema.DataFrameSchema
+import org.jetbrains.kotlinx.jupyter.api.Code
+import java.net.URL
+
+/**
+ * Reader that can read a data frame from a URL. It tries to guess the format based on the given [formats] and returns
+ * [DfReadResult.Success], or returns [DfReadResult.Error] if it fails.
+ */
+public val CodeGenerator.Companion.urlDfReader: (url: URL, formats: List<SupportedFormat>) -> DfReadResult
+    get() = { url, formats ->
+        try {
+            val (format, df) = url.openStream().use {
+                DataFrame.read(
+                    stream = it,
+                    format = guessFormat(url, formats) as? SupportedDataFrameFormat?,
+                    formats = formats.filterIsInstance<SupportedDataFrameFormat>(),
+                )
+            }
+            DfReadResult.Success(df, format)
+        } catch (e: Throwable) {
+            DfReadResult.Error(e)
+        }
+    }
+
+public sealed interface DfReadResult {
+
+    public class Success(private val df: AnyFrame, public val format: SupportedDataFrameFormat) : DfReadResult {
+        public fun getReadDfMethod(pathRepresentation: String?): DefaultReadDfMethod =
+            format.createDefaultReadMethod(pathRepresentation)
+
+        public val schema: DataFrameSchema = df.schema()
+    }
+
+    public class Error(public val reason: Throwable) : DfReadResult
+}
+
+/**
+ * Reader that can read data from a URL and generate code (type schema representations) for it.
+ * It tries to guess the format based on the given [formats] and returns [CodeGenerationReadResult.Success],
+ * or returns [CodeGenerationReadResult.Error] if it fails.
+ */
+public val CodeGenerator.Companion.urlCodeGenReader: (
+    url: URL,
+    name: String,
+    formats: List<SupportedFormat>,
+    generateHelperCompanionObject: Boolean,
+) -> CodeGenerationReadResult
+    get() = { url, name, formats, generateHelperCompanionObject ->
+        try {
+            val (format, code) = url.openStream().use {
+                readCodeForGeneration(
+                    stream = it,
+                    name = name,
+                    format = guessFormat(url, formats) as? SupportedCodeGenerationFormat?,
+                    generateHelperCompanionObject = generateHelperCompanionObject,
+                    formats = formats.filterIsInstance<SupportedCodeGenerationFormat>(),
+                )
+            }
+            CodeGenerationReadResult.Success(code, format)
+        } catch (e: Throwable) {
+            CodeGenerationReadResult.Error(e)
+        }
+    }
+
+public sealed interface CodeGenerationReadResult {
+
+    public class Success(public val code: Code, public val format: SupportedCodeGenerationFormat) :
+        CodeGenerationReadResult {
+        public fun getReadDfMethod(pathRepresentation: String?): DefaultReadDfMethod =
+            format.createDefaultReadMethod(pathRepresentation)
+    }
+
+    public class Error(public val reason: Throwable) : CodeGenerationReadResult
+}
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/AtAnyDepth.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/AtAnyDepth.kt
new file mode 100644
index 000000000..887cc1590
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/AtAnyDepth.kt
@@ -0,0 +1,103 @@
+package org.jetbrains.kotlinx.dataframe.impl.columns
+
+import org.jetbrains.kotlinx.dataframe.api.allColumnsInternal
+import org.jetbrains.kotlinx.dataframe.api.isColumnGroup
+import org.jetbrains.kotlinx.dataframe.columns.ColumnGroup
+import org.jetbrains.kotlinx.dataframe.columns.ColumnResolutionContext
+import org.jetbrains.kotlinx.dataframe.columns.ColumnSet
+import org.jetbrains.kotlinx.dataframe.columns.ColumnWithPath
+import org.jetbrains.kotlinx.dataframe.columns.ColumnsResolver
+import org.jetbrains.kotlinx.dataframe.columns.SingleColumn
+import org.jetbrains.kotlinx.dataframe.impl.columns.tree.flattenRecursively
+
+/**
+ * AtAnyDepth implementation for [TransformableColumnSet].
+ * This converts a [TransformableColumnSet] into a [ColumnSet] by redirecting [ColumnSet.resolve]
+ * to [TransformableColumnSet.transformResolve] with a correctly configured [AtAnyDepthTransformer].
+ */
+internal fun <C> TransformableColumnSet<C>.atAnyDepthImpl(
+    includeGroups: Boolean = true,
+    includeTopLevel: Boolean = true,
+): ColumnSet<C> =
+    object : ColumnSet<C> {
+
+        override fun resolve(context: ColumnResolutionContext): List<ColumnWithPath<C>> =
+            this@atAnyDepthImpl.transformResolve(
+                context = context,
+                transformer = AtAnyDepthTransformer(
+                    includeGroups = includeGroups,
+                    includeTopLevel = includeTopLevel,
+                ),
+            )
+    }
+
+/**
+ * AtAnyDepth implementation for [TransformableSingleColumn].
+ * This converts a [TransformableSingleColumn] into a [SingleColumn] by redirecting [SingleColumn.resolveSingle]
+ * to [TransformableSingleColumn.transformResolveSingle] with a correctly configured [AtAnyDepthTransformer].
+ */
+internal fun <C> TransformableSingleColumn<C>.atAnyDepthImpl(
+    includeGroups: Boolean = true,
+    includeTopLevel: Boolean = true,
+): SingleColumn<C> =
+    object : SingleColumn<C> {
+
+        override fun resolveSingle(context: ColumnResolutionContext): ColumnWithPath<C>? =
+            this@atAnyDepthImpl.transformResolveSingle(
+                context = context,
+                transformer = AtAnyDepthTransformer(
+                    includeGroups = includeGroups,
+                    includeTopLevel = includeTopLevel,
+                ),
+            )
+    }
+
+/**
+ * ## AtAnyDepth transformer.
+ * A [ColumnsResolverTransformer] implementation around the [ColumnsResolver.flattenRecursively] function.
+ * Created only using [atAnyDepthImpl].
+ */
+private class AtAnyDepthTransformer(val includeGroups: Boolean = true, val includeTopLevel: Boolean = true) :
+    ColumnsResolverTransformer {
+
+    override fun transform(columnsResolver: ColumnsResolver<*>): ColumnsResolver<*> =
+        columnsResolver.flattenRecursively(
+            includeGroups = includeGroups,
+            includeTopLevel = includeTopLevel,
+        )
+
+    override fun transformSet(columnSet: ColumnSet<*>): ColumnsResolver<*> =
+        columnSet.flattenRecursively(
+            includeGroups = includeGroups,
+            includeTopLevel = includeTopLevel,
+        )
+
+    override fun transformSingle(singleColumn: SingleColumn<*>): ColumnsResolver<*> =
+        singleColumn.flattenRecursively(
+            includeGroups = includeGroups,
+            includeTopLevel = includeTopLevel,
+        )
+}
+
+/**
+ * Flattens a [ColumnsResolver] recursively.
+ *
+ * If [this] is a [SingleColumn] containing a single [ColumnGroup], the "top-level" is
+ * considered to be the [ColumnGroup]'s children, otherwise, if this is a [ColumnsResolver],
+ * the "top-level" is considered to be the columns in the [ColumnsResolver].
+ *
+ * @param includeGroups Whether to include [ColumnGroup]s in the result.
+ * @param includeTopLevel Whether to include the "top-level" columns in the result.
+ */
+internal fun ColumnsResolver<*>.flattenRecursively(
+    includeGroups: Boolean = true,
+    includeTopLevel: Boolean = true,
+): ColumnsResolver<*> =
+    allColumnsInternal().transform { cols ->
+        if (includeTopLevel) {
+            cols.flattenRecursively()
+        } else {
+            cols.filter { it.isColumnGroup() }
+                .flatMap { it.cols().flattenRecursively() }
+        }.filter { includeGroups || !it.isColumnGroup() }
+    }
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/ColumnAccessorImpl.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/ColumnAccessorImpl.kt
new file mode 100644
index 000000000..e7748770f
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/ColumnAccessorImpl.kt
@@ -0,0 +1,46 @@
+package org.jetbrains.kotlinx.dataframe.impl.columns
+
+import org.jetbrains.kotlinx.dataframe.AnyRow
+import org.jetbrains.kotlinx.dataframe.api.cast
+import org.jetbrains.kotlinx.dataframe.api.isColumnGroup
+import org.jetbrains.kotlinx.dataframe.api.toPath
+import org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor
+import org.jetbrains.kotlinx.dataframe.columns.ColumnPath
+import org.jetbrains.kotlinx.dataframe.columns.ColumnReference
+import org.jetbrains.kotlinx.dataframe.columns.ColumnResolutionContext
+import org.jetbrains.kotlinx.dataframe.columns.ColumnWithPath
+
+internal class ColumnAccessorImpl<T>(val path: ColumnPath) : ColumnAccessor<T> {
+
+    override fun name() = path.last()
+
+    override fun path() = path
+
+    constructor(vararg path: String) : this(path.toPath())
+
+    override fun resolveSingle(context: ColumnResolutionContext): ColumnWithPath<T>? =
+        // resolve the n-1 first columns of the path as column groups (throwing an exception if any of them is not a column group)
+        path.dropLast().foldIndexed(context.df) { i, df, colName ->
+            val col = df.getColumn<Any?>(colName, context.unresolvedColumnsPolicy) ?: return null
+            if (!col.isColumnGroup()) {
+                error(
+                    "Cannot resolve column '${path.subList(0, i + 2).joinToString(".")}': " +
+                        "Column '${path.subList(0, i + 1).joinToString(".")}' is not a column group.",
+                )
+            } else {
+                col
+            }
+        }
+            // resolve the last column of the path
+            .getColumn<Any?>(path.last(), context.unresolvedColumnsPolicy)
+            ?.cast<T>()
+            ?.addPath(path)
+
+    override fun rename(newName: String) = ColumnAccessorImpl<T>(path.dropLast(1) + newName)
+
+    override fun <C> get(column: ColumnReference<C>) = ColumnAccessorImpl<C>(path + column.path())
+
+    override fun getValue(row: AnyRow) = path.getValue(row) as T
+
+    override fun getValueOrNull(row: AnyRow) = path.getValueOrNull(row) as T
+}
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/ColumnGroupImpl.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/ColumnGroupImpl.kt
new file mode 100644
index 000000000..27829eaea
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/ColumnGroupImpl.kt
@@ -0,0 +1,113 @@
+package org.jetbrains.kotlinx.dataframe.impl.columns
+
+import org.jetbrains.kotlinx.dataframe.AnyCol
+import org.jetbrains.kotlinx.dataframe.AnyRow
+import org.jetbrains.kotlinx.dataframe.DataColumn
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.DataRow
+import org.jetbrains.kotlinx.dataframe.api.asColumnGroup
+import org.jetbrains.kotlinx.dataframe.api.firstOrNull
+import org.jetbrains.kotlinx.dataframe.api.getColumn
+import org.jetbrains.kotlinx.dataframe.api.rows
+import org.jetbrains.kotlinx.dataframe.columns.ColumnGroup
+import org.jetbrains.kotlinx.dataframe.columns.ColumnResolutionContext
+import org.jetbrains.kotlinx.dataframe.impl.DataFrameImpl
+import org.jetbrains.kotlinx.dataframe.impl.createTypeWithArgument
+import org.jetbrains.kotlinx.dataframe.impl.renderSchema
+import org.jetbrains.kotlinx.dataframe.nrow
+import kotlin.reflect.KType
+
+internal val anyRowType = createTypeWithArgument<AnyRow>()
+
+internal open class ColumnGroupImpl<T>(private val name: String, df: DataFrame<T>) :
+    DataFrameImpl<T>(df.columns(), df.nrow),
+    DataColumnInternal<DataRow<T>>,
+    DataColumnGroup<T> {
+
+    override fun values() = rows()
+
+    override fun countDistinct() = distinct.value.size
+
+    override fun type() = anyRowType
+
+    private val distinct = lazy { df.rows().toSet() }
+
+    override fun toSet() = distinct.value
+
+    override fun size() = rowsCount()
+
+    override fun get(index: Int) = super<DataFrameImpl>.get(index)
+
+    override fun get(firstIndex: Int, vararg otherIndices: Int) =
+        ColumnGroupImpl(name, super<DataFrameImpl>.get(firstIndex, *otherIndices))
+
+    override fun rename(newName: String) = if (newName == name) this else ColumnGroupImpl(newName, this)
+
+    override fun defaultValue() = null
+
+    override fun get(indices: Iterable<Int>) = ColumnGroupImpl(name, super<DataFrameImpl>.get(indices))
+
+    override fun addParent(parent: ColumnGroup<*>): DataColumn<DataRow<T>> = ColumnGroupWithParent(parent, this)
+
+    override fun equals(other: Any?): Boolean {
+        if (this === other) return true
+        val g = other as? ColumnGroup<*> ?: return false
+        return name == g.name() && columns == other.columns()
+    }
+
+    private fun computeHashCode() = name.hashCode() * 31 + super.hashCode()
+
+    private val hashCode by lazy { computeHashCode() }
+
+    override fun hashCode() = hashCode
+
+    override fun toString() = "$name: {${renderSchema(this)}}"
+
+    override fun changeType(type: KType) = throw UnsupportedOperationException()
+
+    override fun name() = name
+
+    override fun distinct() = ColumnGroupImpl(name, get(distinct.value.map { it.index() }))
+
+    override fun resolve(context: ColumnResolutionContext) = super<DataColumnInternal>.resolve(context)
+
+    override fun resolveSingle(context: ColumnResolutionContext) = super<DataColumnInternal>.resolveSingle(context)
+
+    override fun iterator() = super<DataFrameImpl>.iterator()
+
+    override fun forceResolve() = ResolvingColumnGroup(this)
+
+    override fun get(range: IntRange) = ColumnGroupImpl(name, super<DataFrameImpl>.get(range))
+
+    override fun get(columnName: String): AnyCol = getColumn(columnName)
+
+    override fun contains(value: DataRow<T>) =
+        if (distinct.isInitialized()) {
+            distinct.value.contains(value)
+        } else {
+            asColumnGroup()
+                .firstOrNull { it == value } != null
+        }
+}
+
+internal class ResolvingColumnGroup<T>(override val source: ColumnGroupImpl<T>) :
+    DataColumnGroup<T> by source,
+    ForceResolvedColumn<DataRow<T>> {
+
+    override fun resolve(context: ColumnResolutionContext) = super<DataColumnGroup>.resolve(context)
+
+    override fun resolveSingle(context: ColumnResolutionContext) =
+        context.df.getColumn<DataRow<T>>(source.name(), context.unresolvedColumnsPolicy)?.addPath()
+
+    override fun getValue(row: AnyRow) = super<DataColumnGroup>.getValue(row)
+
+    override fun getValueOrNull(row: AnyRow) = super<DataColumnGroup>.getValueOrNull(row)
+
+    override fun rename(newName: String) = ResolvingColumnGroup(source.rename(newName))
+
+    override fun toString(): String = source.toString()
+
+    override fun equals(other: Any?) = source.checkEquals(other)
+
+    override fun hashCode(): Int = source.hashCode()
+}
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/ColumnGroupWithParent.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/ColumnGroupWithParent.kt
new file mode 100644
index 000000000..243fe7791
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/ColumnGroupWithParent.kt
@@ -0,0 +1,84 @@
+package org.jetbrains.kotlinx.dataframe.impl.columns
+
+import org.jetbrains.kotlinx.dataframe.AnyCol
+import org.jetbrains.kotlinx.dataframe.ColumnGroupReference
+import org.jetbrains.kotlinx.dataframe.ColumnSelector
+import org.jetbrains.kotlinx.dataframe.ColumnsSelector
+import org.jetbrains.kotlinx.dataframe.DataColumn
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.DataRow
+import org.jetbrains.kotlinx.dataframe.api.asColumnGroup
+import org.jetbrains.kotlinx.dataframe.api.cast
+import org.jetbrains.kotlinx.dataframe.api.castFrameColumn
+import org.jetbrains.kotlinx.dataframe.api.getColumn
+import org.jetbrains.kotlinx.dataframe.api.getColumnWithPath
+import org.jetbrains.kotlinx.dataframe.columns.ColumnGroup
+import org.jetbrains.kotlinx.dataframe.columns.ColumnPath
+import org.jetbrains.kotlinx.dataframe.columns.ColumnReference
+import org.jetbrains.kotlinx.dataframe.columns.ColumnResolutionContext
+import org.jetbrains.kotlinx.dataframe.columns.FrameColumn
+import org.jetbrains.kotlinx.dataframe.impl.columnName
+import kotlin.reflect.KProperty
+
+internal class ColumnGroupWithParent<T>(
+    override val parent: ColumnGroupReference?,
+    override val source: ColumnGroup<T>,
+) : ColumnGroupImpl<T>(source.name(), source),
+    ColumnWithParent<DataRow<T>> {
+
+    override fun path() = super<ColumnWithParent>.path()
+
+    override fun getValue(thisRef: Any?, property: KProperty<*>): DataColumnGroup<T> =
+        source.getValue(thisRef, property) as DataColumnGroup<T>
+
+    override fun equals(other: Any?) = source.checkEquals(other)
+
+    override fun hashCode() = source.hashCode()
+
+    override fun resolveSingle(context: ColumnResolutionContext) = super<ColumnWithParent>.resolveSingle(context)
+
+    override fun resolve(context: ColumnResolutionContext) = super<ColumnWithParent>.resolve(context)
+
+    // region get column
+
+    override fun columns() = super.columns().map { it.addParent(this) }
+
+    override fun getColumnOrNull(index: Int) = super.getColumnOrNull(index)?.addParent(this)
+
+    override fun getColumnOrNull(name: String) = super.getColumnOrNull(name)?.addParent(this)
+
+    override fun <R> getColumnOrNull(column: ColumnReference<R>) = super.getColumnOrNull(column)?.addParent(this)
+
+    override fun getColumnOrNull(path: ColumnPath) =
+        path.fold(this as AnyCol?) { col, name ->
+            col?.asColumnGroup()?.getColumnOrNull(name)
+        }
+
+    override fun <R> getColumnOrNull(column: ColumnSelector<T, R>) =
+        getColumnOrNull(getColumnWithPath(column).path)?.cast<R>()
+
+    override operator fun get(columnName: String): AnyCol = getColumn(columnName)
+
+    override operator fun get(columnPath: ColumnPath): AnyCol = getColumn(columnPath)
+
+    override operator fun <R> get(column: KProperty<R>): DataColumn<R> = get(column.columnName).cast()
+
+    override operator fun <R> get(column: KProperty<DataRow<R>>): ColumnGroup<R> =
+        get(column.columnName).asColumnGroup().cast()
+
+    override operator fun <R> get(column: KProperty<DataFrame<R>>): FrameColumn<R> =
+        get(column.columnName).asAnyFrameColumn().castFrameColumn()
+
+    override operator fun <C> get(columns: ColumnsSelector<T, C>): List<DataColumn<C>> =
+        super.get(columns).map {
+            it.addParent(this)
+        }
+
+    override operator fun <C> get(column: ColumnSelector<T, C>): DataColumn<C> =
+        get(column as ColumnsSelector<T, C>).single()
+
+    // endregion
+
+    override fun get(firstIndex: Int, vararg otherIndices: Int) =
+        ColumnGroupWithParent(parent, super.get(firstIndex, *otherIndices))
+}
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/ColumnGroupWithPathImpl.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/ColumnGroupWithPathImpl.kt
new file mode 100644
index 000000000..99899cbfd
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/ColumnGroupWithPathImpl.kt
@@ -0,0 +1,30 @@
+package org.jetbrains.kotlinx.dataframe.impl.columns
+
+import org.jetbrains.kotlinx.dataframe.DataColumn
+import org.jetbrains.kotlinx.dataframe.DataRow
+import org.jetbrains.kotlinx.dataframe.api.name
+import org.jetbrains.kotlinx.dataframe.columns.ColumnGroup
+import org.jetbrains.kotlinx.dataframe.columns.ColumnPath
+import org.jetbrains.kotlinx.dataframe.columns.ColumnWithPath
+
+internal class ColumnGroupWithPathImpl<T> internal constructor(
+    val column: ColumnGroup<T>,
+    override val path: ColumnPath,
+) : ColumnGroupImpl<T>(column.name, column),
+    ColumnWithPath<DataRow<T>> {
+
+    override fun rename(newName: String) =
+        if (newName == name()) {
+            this
+        } else {
+            ColumnGroupWithPathImpl(
+                column = column.rename(newName),
+                path = path.dropLast(1) + newName,
+            )
+        }
+
+    override val data: DataColumn<DataRow<T>>
+        get() = column as DataColumn<DataRow<T>>
+
+    override fun path() = path
+}
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/ColumnWithParent.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/ColumnWithParent.kt
new file mode 100644
index 000000000..bb3787510
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/ColumnWithParent.kt
@@ -0,0 +1,35 @@
+package org.jetbrains.kotlinx.dataframe.impl.columns
+
+import org.jetbrains.kotlinx.dataframe.ColumnGroupReference
+import org.jetbrains.kotlinx.dataframe.api.asColumnGroup
+import org.jetbrains.kotlinx.dataframe.api.pathOf
+import org.jetbrains.kotlinx.dataframe.columns.BaseColumn
+import org.jetbrains.kotlinx.dataframe.columns.ColumnReference
+import org.jetbrains.kotlinx.dataframe.columns.ColumnResolutionContext
+import org.jetbrains.kotlinx.dataframe.columns.ColumnWithPath
+import org.jetbrains.kotlinx.dataframe.impl.emptyPath
+
+internal interface ColumnWithParent<out C> : ColumnReference<C> {
+
+    val parent: ColumnGroupReference?
+
+    val source: BaseColumn<C>
+
+    override fun path() = parent?.path()?.plus(name()) ?: pathOf(name())
+
+    override fun resolveSingle(context: ColumnResolutionContext): ColumnWithPath<C>? {
+        val parentDef = parent
+        val (targetDf, pathPrefix) = when (parentDef) {
+            null -> context.df to emptyPath()
+
+            else -> {
+                val parentCol = parentDef.resolveSingle(context) ?: return null
+                val group = parentCol.data.asColumnGroup()
+                group to parentCol.path
+            }
+        }
+
+        val data = targetDf.getColumn<C>(name(), context.unresolvedColumnsPolicy)
+        return data?.addPath(pathPrefix + name())
+    }
+}
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/ColumnsList.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/ColumnsList.kt
new file mode 100644
index 000000000..30a7b269a
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/ColumnsList.kt
@@ -0,0 +1,11 @@
+package org.jetbrains.kotlinx.dataframe.impl.columns
+
+import org.jetbrains.kotlinx.dataframe.columns.ColumnResolutionContext
+import org.jetbrains.kotlinx.dataframe.columns.ColumnSet
+import org.jetbrains.kotlinx.dataframe.columns.ColumnsResolver
+
+internal class ColumnsList<C>(val columns: List<ColumnsResolver<C>>) : ColumnSet<C> {
+    constructor(vararg columns: ColumnsResolver<C>) : this(columns.toList())
+
+    override fun resolve(context: ColumnResolutionContext) = columns.flatMap { it.resolve(context) }
+}
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/ComputedColumnReference.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/ComputedColumnReference.kt
new file mode 100644
index 000000000..763cd1b8f
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/ComputedColumnReference.kt
@@ -0,0 +1,38 @@
+package org.jetbrains.kotlinx.dataframe.impl.columns
+
+import org.jetbrains.kotlinx.dataframe.AnyRow
+import org.jetbrains.kotlinx.dataframe.RowExpression
+import org.jetbrains.kotlinx.dataframe.api.Infer
+import org.jetbrains.kotlinx.dataframe.columns.ColumnReference
+import org.jetbrains.kotlinx.dataframe.columns.ColumnResolutionContext
+import org.jetbrains.kotlinx.dataframe.columns.ColumnWithPath
+import kotlin.reflect.KType
+
+internal class ComputedColumnReference<R>(
+    val name: String,
+    val type: KType,
+    val infer: Infer,
+    val compute: RowExpression<Any?, R>,
+) : ColumnReference<R> {
+
+    override fun resolveSingle(context: ColumnResolutionContext): ColumnWithPath<R> =
+        context.df
+            .newColumn(type, name, infer) { compute(it, it) }
+            .addPath()
+
+    override fun name() = name
+
+    override fun rename(newName: String) = ComputedColumnReference(newName, type, infer, compute)
+
+    override fun getValue(row: AnyRow) = compute(row, row)
+
+    override fun getValueOrNull(row: AnyRow) = compute(row, row)
+}
+
+@PublishedApi
+internal fun <R> createComputedColumnReference(
+    name: String,
+    type: KType,
+    infer: Infer,
+    compute: RowExpression<Any?, R>,
+): ColumnReference<R> = ComputedColumnReference(name, type, infer, compute)
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/DataColumnGroup.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/DataColumnGroup.kt
new file mode 100644
index 000000000..0e2d0e792
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/DataColumnGroup.kt
@@ -0,0 +1,24 @@
+package org.jetbrains.kotlinx.dataframe.impl.columns
+
+import org.jetbrains.kotlinx.dataframe.DataColumn
+import org.jetbrains.kotlinx.dataframe.DataRow
+import org.jetbrains.kotlinx.dataframe.columns.ColumnGroup
+import kotlin.reflect.KProperty
+
+internal interface DataColumnGroup<out T> :
+    ColumnGroup<T>,
+    DataColumn<DataRow<T>> {
+
+    override operator fun getValue(thisRef: Any?, property: KProperty<*>): DataColumnGroup<T> =
+        super<DataColumn>.getValue(thisRef, property) as DataColumnGroup<T>
+
+    override fun iterator() = super<ColumnGroup>.iterator()
+
+    override fun rename(newName: String): DataColumnGroup<T>
+
+    override fun get(indices: Iterable<Int>): DataColumnGroup<T>
+
+    override fun distinct(): DataColumnGroup<T>
+
+    override fun get(range: IntRange): DataColumnGroup<T>
+}
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/DataColumnImpl.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/DataColumnImpl.kt
new file mode 100644
index 000000000..cdc6eaae7
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/DataColumnImpl.kt
@@ -0,0 +1,81 @@
+package org.jetbrains.kotlinx.dataframe.impl.columns
+
+import org.jetbrains.kotlinx.dataframe.BuildConfig
+import org.jetbrains.kotlinx.dataframe.DataColumn
+import org.jetbrains.kotlinx.dataframe.api.dataFrameOf
+import org.jetbrains.kotlinx.dataframe.impl.isArray
+import org.jetbrains.kotlinx.dataframe.impl.isPrimitiveArray
+import org.jetbrains.kotlinx.dataframe.kind
+import kotlin.reflect.KClass
+import kotlin.reflect.KType
+import kotlin.reflect.full.isSubclassOf
+import kotlin.reflect.full.isSubtypeOf
+import kotlin.reflect.typeOf
+
+internal abstract class DataColumnImpl<T>(
+    protected val values: List<T>,
+    val name: String,
+    val type: KType,
+    distinct: Lazy<Set<T>>? = null,
+) : DataColumn<T>,
+    DataColumnInternal<T> {
+
+    private infix fun <T> T?.matches(type: KType) =
+        when {
+            this == null -> type.isMarkedNullable
+
+            // special case since functions are often stored as a $$Lambda$... class, the subClassOf check would fail
+            this is Function<*> && type.isSubtypeOf(typeOf<Function<*>?>()) -> true
+
+            this.isPrimitiveArray ->
+                type.isPrimitiveArray &&
+                    this!!::class.qualifiedName == type.classifier?.let { (it as KClass<*>).qualifiedName }
+
+            this.isArray -> type.isArray
+
+            // cannot check the precise type of array
+            else -> this!!::class.isSubclassOf(type.classifier as KClass<*>)
+        }
+
+    init {
+        // Check for [Issue #713](https://github.com/Kotlin/dataframe/issues/713).
+        // This only runs with `kotlin.dataframe.debug=true` in gradle.properties.
+        if (BuildConfig.DEBUG) {
+            require(values.all { it matches type }) {
+                val types = values.map { if (it == null) "Nothing?" else it!!::class.simpleName }.distinct()
+                "Values of $kind '$name' have types '$types' which are not compatible given with column type '$type'"
+            }
+        }
+    }
+
+    protected val distinct = distinct ?: lazy { values.toSet() }
+
+    override fun name() = name
+
+    override fun values() = values
+
+    override fun type() = type
+
+    override fun toSet() = distinct.value
+
+    override fun contains(value: T): Boolean =
+        if (distinct.isInitialized()) distinct.value.contains(value) else values.contains(value)
+
+    override fun toString() = dataFrameOf(this).toString() // "${name()}: $type"
+
+    override fun countDistinct() = toSet().size
+
+    override fun get(index: Int) = values[index]
+
+    override fun size() = values.size
+
+    override fun equals(other: Any?) = checkEquals(other)
+
+    private val hashCode by lazy { getHashCode() }
+
+    override fun hashCode() = hashCode
+
+    override operator fun get(range: IntRange) = createWithValues(values.subList(range.first, range.last + 1))
+
+    protected abstract fun createWithValues(values: List<T>, hasNulls: Boolean? = null): DataColumn<T>
+}
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/DataColumnInternal.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/DataColumnInternal.kt
new file mode 100644
index 000000000..e94ff7c84
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/DataColumnInternal.kt
@@ -0,0 +1,24 @@
+package org.jetbrains.kotlinx.dataframe.impl.columns
+
+import org.jetbrains.kotlinx.dataframe.AnyCol
+import org.jetbrains.kotlinx.dataframe.DataColumn
+import org.jetbrains.kotlinx.dataframe.columns.ColumnGroup
+import kotlin.reflect.KType
+
+internal interface DataColumnInternal<T> : DataColumn<T> {
+
+    override fun rename(newName: String): DataColumnInternal<T>
+
+    fun forceResolve(): DataColumn<T>
+
+    fun changeType(type: KType): DataColumn<T>
+
+    fun addParent(parent: ColumnGroup<*>): DataColumn<T>
+}
+
+internal fun <T> DataColumn<T>.internal() = this as DataColumnInternal<T>
+
+// TODO: replace forced column resolution with column origin tracking
+@PublishedApi
+internal fun <T : AnyCol> T.forceResolve(): T =
+    if (this is ForceResolvedColumn<*>) this else internal().forceResolve() as T
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/DistinctColumnSet.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/DistinctColumnSet.kt
new file mode 100644
index 000000000..f705c09f2
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/DistinctColumnSet.kt
@@ -0,0 +1,11 @@
+package org.jetbrains.kotlinx.dataframe.impl.columns
+
+import org.jetbrains.kotlinx.dataframe.columns.ColumnResolutionContext
+import org.jetbrains.kotlinx.dataframe.columns.ColumnSet
+import org.jetbrains.kotlinx.dataframe.columns.ColumnWithPath
+import org.jetbrains.kotlinx.dataframe.columns.ColumnsResolver
+
+internal class DistinctColumnSet<T>(val src: ColumnsResolver<T>) : ColumnSet<T> {
+    override fun resolve(context: ColumnResolutionContext): List<ColumnWithPath<T>> =
+        src.resolve(context).distinctBy { it.path }
+}
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/ForceResolvedColumn.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/ForceResolvedColumn.kt
new file mode 100644
index 000000000..686a89c84
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/ForceResolvedColumn.kt
@@ -0,0 +1,7 @@
+package org.jetbrains.kotlinx.dataframe.impl.columns
+
+import org.jetbrains.kotlinx.dataframe.DataColumn
+
+internal interface ForceResolvedColumn<T> : DataColumn<T> {
+    val source: DataColumn<T>
+}
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/FrameColumnImpl.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/FrameColumnImpl.kt
new file mode 100644
index 000000000..d07c0b9d0
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/FrameColumnImpl.kt
@@ -0,0 +1,78 @@
+package org.jetbrains.kotlinx.dataframe.impl.columns
+
+import org.jetbrains.kotlinx.dataframe.AnyRow
+import org.jetbrains.kotlinx.dataframe.DataColumn
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.api.schema
+import org.jetbrains.kotlinx.dataframe.columns.ColumnGroup
+import org.jetbrains.kotlinx.dataframe.columns.ColumnResolutionContext
+import org.jetbrains.kotlinx.dataframe.columns.FrameColumn
+import org.jetbrains.kotlinx.dataframe.impl.createStarProjectedType
+import org.jetbrains.kotlinx.dataframe.impl.schema.intersectSchemas
+import org.jetbrains.kotlinx.dataframe.nrow
+import org.jetbrains.kotlinx.dataframe.schema.DataFrameSchema
+import kotlin.reflect.KType
+
+internal open class FrameColumnImpl<T> constructor(
+    name: String,
+    values: List<DataFrame<T>>,
+    columnSchema: Lazy<DataFrameSchema>? = null,
+    distinct: Lazy<Set<DataFrame<T>>>? = null,
+) : DataColumnImpl<DataFrame<T>>(
+        values = values,
+        name = name,
+        type = DataFrame::class.createStarProjectedType(false),
+        distinct = distinct,
+    ),
+    FrameColumn<T> {
+
+    override fun rename(newName: String) = FrameColumnImpl(newName, values, schema, distinct)
+
+    override fun defaultValue() = null
+
+    override fun addParent(parent: ColumnGroup<*>) = FrameColumnWithParent(parent, this)
+
+    override fun createWithValues(values: List<DataFrame<T>>, hasNulls: Boolean?) =
+        DataColumn.createFrameColumn(name, values)
+
+    override fun changeType(type: KType) = throw UnsupportedOperationException()
+
+    override fun distinct() = FrameColumnImpl(name, distinct.value.toList(), schema, distinct)
+
+    override val schema: Lazy<DataFrameSchema> = columnSchema ?: lazy {
+        values.mapNotNull { it.takeIf { it.nrow > 0 }?.schema() }.intersectSchemas()
+    }
+
+    override fun forceResolve() = ResolvingFrameColumn(this)
+
+    override fun get(indices: Iterable<Int>): FrameColumn<T> =
+        DataColumn.createFrameColumn(
+            name = name,
+            groups = indices.map { values[it] },
+        )
+
+    override fun get(columnName: String) =
+        throw UnsupportedOperationException("Can not get nested column '$columnName' from FrameColumn '$name'")
+}
+
+internal class ResolvingFrameColumn<T>(override val source: FrameColumn<T>) :
+    FrameColumn<T> by source,
+    ForceResolvedColumn<DataFrame<T>> {
+
+    override fun resolve(context: ColumnResolutionContext) = super<FrameColumn>.resolve(context)
+
+    override fun resolveSingle(context: ColumnResolutionContext) =
+        context.df.getColumn<DataFrame<T>>(source.name(), context.unresolvedColumnsPolicy)?.addPath()
+
+    override fun getValue(row: AnyRow) = super<FrameColumn>.getValue(row)
+
+    override fun getValueOrNull(row: AnyRow) = super<FrameColumn>.getValueOrNull(row)
+
+    override fun rename(newName: String) = ResolvingFrameColumn(source.rename(newName))
+
+    override fun toString(): String = source.toString()
+
+    override fun equals(other: Any?) = source.checkEquals(other)
+
+    override fun hashCode(): Int = source.hashCode()
+}
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/FrameColumnWithParent.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/FrameColumnWithParent.kt
new file mode 100644
index 000000000..0faa3cbfc
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/FrameColumnWithParent.kt
@@ -0,0 +1,33 @@
+package org.jetbrains.kotlinx.dataframe.impl.columns
+
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.api.asFrameColumn
+import org.jetbrains.kotlinx.dataframe.columns.ColumnGroup
+import org.jetbrains.kotlinx.dataframe.columns.ColumnResolutionContext
+import org.jetbrains.kotlinx.dataframe.columns.FrameColumn
+import kotlin.reflect.KType
+
+internal class FrameColumnWithParent<T>(override val parent: ColumnGroup<*>, override val source: FrameColumn<T>) :
+    ColumnWithParent<DataFrame<T>>,
+    FrameColumn<T> by source,
+    DataColumnInternal<DataFrame<T>> {
+
+    override fun equals(other: Any?) = source.checkEquals(other)
+
+    override fun hashCode() = source.hashCode()
+
+    override fun path() = super<ColumnWithParent>.path()
+
+    override fun resolve(context: ColumnResolutionContext) = super<ColumnWithParent>.resolve(context)
+
+    override fun resolveSingle(context: ColumnResolutionContext) = super<ColumnWithParent>.resolveSingle(context)
+
+    override fun forceResolve() = ResolvingFrameColumn(this)
+
+    override fun changeType(type: KType) =
+        FrameColumnWithParent(parent, source.internal().changeType(type).asFrameColumn())
+
+    override fun addParent(parent: ColumnGroup<*>) = FrameColumnWithParent(parent, source)
+
+    override fun rename(newName: String) = FrameColumnWithParent(parent, source.rename(newName))
+}
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/FrameColumnWithPathImpl.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/FrameColumnWithPathImpl.kt
new file mode 100644
index 000000000..806eefa45
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/FrameColumnWithPathImpl.kt
@@ -0,0 +1,25 @@
+package org.jetbrains.kotlinx.dataframe.impl.columns
+
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.columns.ColumnPath
+import org.jetbrains.kotlinx.dataframe.columns.ColumnWithPath
+import org.jetbrains.kotlinx.dataframe.columns.FrameColumn
+
+internal class FrameColumnWithPathImpl<T> internal constructor(
+    override val data: FrameColumn<T>,
+    override val path: ColumnPath,
+) : ColumnWithPath<DataFrame<T>>,
+    FrameColumn<T> by data {
+
+    override fun rename(newName: String) =
+        if (newName == name()) {
+            this
+        } else {
+            FrameColumnWithPathImpl(
+                data = data.rename(newName),
+                path = path.dropLast(1) + newName,
+            )
+        }
+
+    override fun path() = path
+}
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/RenamedColumnReference.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/RenamedColumnReference.kt
new file mode 100644
index 000000000..d56f3b085
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/RenamedColumnReference.kt
@@ -0,0 +1,22 @@
+package org.jetbrains.kotlinx.dataframe.impl.columns
+
+import org.jetbrains.kotlinx.dataframe.AnyRow
+import org.jetbrains.kotlinx.dataframe.columns.ColumnReference
+import org.jetbrains.kotlinx.dataframe.columns.ColumnResolutionContext
+import org.jetbrains.kotlinx.dataframe.columns.ColumnWithPath
+
+internal class RenamedColumnReference<C>(val source: ColumnReference<C>, val name: String) : ColumnReference<C> {
+
+    override fun resolveSingle(context: ColumnResolutionContext): ColumnWithPath<C>? =
+        source.resolveSingle(context)?.let {
+            it.data.rename(name).addPath(it.path)
+        }
+
+    override fun name() = name
+
+    override fun rename(newName: String) = RenamedColumnReference(source, newName)
+
+    override fun getValue(row: AnyRow) = source.getValue(row)
+
+    override fun getValueOrNull(row: AnyRow) = source.getValueOrNull(row)
+}
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/TransformableColumnSet.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/TransformableColumnSet.kt
new file mode 100644
index 000000000..f8c6d2a20
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/TransformableColumnSet.kt
@@ -0,0 +1,64 @@
+package org.jetbrains.kotlinx.dataframe.impl.columns
+
+import org.jetbrains.kotlinx.dataframe.api.colsInternal
+import org.jetbrains.kotlinx.dataframe.api.singleInternal
+import org.jetbrains.kotlinx.dataframe.columns.ColumnResolutionContext
+import org.jetbrains.kotlinx.dataframe.columns.ColumnSet
+import org.jetbrains.kotlinx.dataframe.columns.ColumnWithPath
+import org.jetbrains.kotlinx.dataframe.columns.ColumnsResolver
+import org.jetbrains.kotlinx.dataframe.columns.SingleColumn
+
+/**
+ * ## Transformable ColumnSet
+ * This type of [ColumnsResolver] can be [transformed][transformResolve] before being resolved.
+ *
+ * This is especially useful for calls like
+ * [colsInternal { }][ColumnsResolver.colsInternal].[atAnyDepthImpl()][atAnyDepthImpl],
+ * where [atAnyDepthImpl][atAnyDepthImpl] modifies the [ColumnSet][ColumnsResolver]
+ * that [colsInternal { }][ColumnsResolver.colsInternal] operates on to include ALL columns, including those inside
+ * column groups, before it's evaluated.
+ *
+ * @see [ColumnsResolver]
+ * @see [TransformableSingleColumn]
+ * @see [SingleColumn]
+ */
+public interface TransformableColumnSet<out C> : ColumnSet<C> {
+    public fun transformResolve(
+        context: ColumnResolutionContext,
+        transformer: ColumnsResolverTransformer,
+    ): List<ColumnWithPath<C>>
+}
+
+/**
+ * ## Transformable SingleColumn
+ * This type of [SingleColumn] can be [transformed][transformResolveSingle] before being resolved.
+ *
+ * This is especially useful for calls like
+ * [singleInternal { }][ColumnsResolver.singleInternal].[atAnyDepthImpl()][atAnyDepthImpl],
+ * where [atAnyDepthImpl][atAnyDepthImpl] modifies the [SingleColumn]
+ * that [singleInternal { }][ColumnsResolver.singleInternal] operates on to include ALL columns, including those inside
+ * column groups, before it's evaluated.
+ *
+ * @see [SingleColumn]
+ * @see [TransformableColumnSet]
+ * @see [ColumnsResolver]
+ */
+public interface TransformableSingleColumn<out C> : SingleColumn<C> {
+    public fun transformResolveSingle(
+        context: ColumnResolutionContext,
+        transformer: ColumnsResolverTransformer,
+    ): ColumnWithPath<C>?
+}
+
+/**
+ * ## Columns Resolver Transformer.
+ * This contains implementations for both [transform][ColumnSet.transform] and
+ * [transformSingle][SingleColumn.transformSingle] and can be passed around.
+ */
+public interface ColumnsResolverTransformer {
+    public fun transform(columnsResolver: ColumnsResolver<*>): ColumnsResolver<*>
+
+    public fun transformSet(columnSet: ColumnSet<*>): ColumnsResolver<*>
+
+    public fun transformSingle(singleColumn: SingleColumn<*>): ColumnsResolver<*>
+}
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/Utils.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/Utils.kt
new file mode 100644
index 000000000..4df8f5cda
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/Utils.kt
@@ -0,0 +1,505 @@
+package org.jetbrains.kotlinx.dataframe.impl.columns
+
+import org.jetbrains.kotlinx.dataframe.AnyBaseCol
+import org.jetbrains.kotlinx.dataframe.AnyCol
+import org.jetbrains.kotlinx.dataframe.ColumnsContainer
+import org.jetbrains.kotlinx.dataframe.DataColumn
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.DataRow
+import org.jetbrains.kotlinx.dataframe.api.asColumnGroup
+import org.jetbrains.kotlinx.dataframe.api.cast
+import org.jetbrains.kotlinx.dataframe.api.name
+import org.jetbrains.kotlinx.dataframe.api.pathOf
+import org.jetbrains.kotlinx.dataframe.api.remove
+import org.jetbrains.kotlinx.dataframe.api.replace
+import org.jetbrains.kotlinx.dataframe.api.with
+import org.jetbrains.kotlinx.dataframe.columns.BaseColumn
+import org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor
+import org.jetbrains.kotlinx.dataframe.columns.ColumnGroup
+import org.jetbrains.kotlinx.dataframe.columns.ColumnKind
+import org.jetbrains.kotlinx.dataframe.columns.ColumnPath
+import org.jetbrains.kotlinx.dataframe.columns.ColumnReference
+import org.jetbrains.kotlinx.dataframe.columns.ColumnResolutionContext
+import org.jetbrains.kotlinx.dataframe.columns.ColumnSet
+import org.jetbrains.kotlinx.dataframe.columns.ColumnWithPath
+import org.jetbrains.kotlinx.dataframe.columns.ColumnsResolver
+import org.jetbrains.kotlinx.dataframe.columns.FrameColumn
+import org.jetbrains.kotlinx.dataframe.columns.SingleColumn
+import org.jetbrains.kotlinx.dataframe.columns.UnresolvedColumnsPolicy
+import org.jetbrains.kotlinx.dataframe.columns.ValueColumn
+import org.jetbrains.kotlinx.dataframe.columns.values
+import org.jetbrains.kotlinx.dataframe.impl.DataFrameImpl
+import org.jetbrains.kotlinx.dataframe.impl.asNullable
+import org.jetbrains.kotlinx.dataframe.impl.columns.missing.MissingDataColumn
+import org.jetbrains.kotlinx.dataframe.impl.columns.tree.ColumnPosition
+import org.jetbrains.kotlinx.dataframe.impl.columns.tree.TreeNode
+import org.jetbrains.kotlinx.dataframe.impl.columns.tree.collectTree
+import org.jetbrains.kotlinx.dataframe.impl.columns.tree.getOrPut
+import org.jetbrains.kotlinx.dataframe.impl.columns.tree.put
+import org.jetbrains.kotlinx.dataframe.impl.columns.tree.topmostChildren
+import org.jetbrains.kotlinx.dataframe.impl.equalsByElement
+import org.jetbrains.kotlinx.dataframe.impl.rollingHash
+import org.jetbrains.kotlinx.dataframe.nrow
+import org.jetbrains.kotlinx.dataframe.type
+import kotlin.reflect.KType
+import kotlin.reflect.full.isSubtypeOf
+import kotlin.reflect.jvm.jvmErasure
+import kotlin.reflect.typeOf
+
+internal fun <T> BaseColumn<T>.checkEquals(other: Any?): Boolean {
+    if (this === other) return true
+
+    if (this !is AnyCol) return false
+    if (other !is AnyCol) return false
+
+    if (name != other.name) return false
+    if (type != other.type) return false
+    return values.equalsByElement(other.values)
+}
+
+internal fun AnyCol.getHashCode(): Int {
+    var result = values.rollingHash()
+    result = 31 * result + name().hashCode()
+    result = 31 * result + type.hashCode()
+    return result
+}
+
+internal fun <C> TreeNode<ColumnPosition>.toColumnWithPath() = (data.column as DataColumn<C>).addPath(pathFromRoot())
+
+internal fun <T> BaseColumn<T>.addPath(path: ColumnPath): ColumnWithPath<T> =
+    when (this) {
+        is ValueColumn<T> -> ValueColumnWithPathImpl(this, path)
+        is FrameColumn<*> -> FrameColumnWithPathImpl(this, path) as ColumnWithPath<T>
+        is ColumnGroup<*> -> ColumnGroupWithPathImpl(this, path) as ColumnWithPath<T>
+        else -> throw IllegalArgumentException("Can't add path to ${this.javaClass}")
+    }
+
+internal fun <T> ColumnWithPath<T>.changePath(path: ColumnPath): ColumnWithPath<T> = data.addPath(path)
+
+internal fun <T> BaseColumn<T>.addParentPath(path: ColumnPath) = addPath(path + name)
+
+internal fun <T> BaseColumn<T>.addPath(): ColumnWithPath<T> = addPath(pathOf(name))
+
+internal fun ColumnPath.depth() = size - 1
+
+internal fun <T> AnyCol.asValues(): ValueColumn<T> = this as ValueColumn<T>
+
+internal fun <T> DataColumn<T>.asValueColumn(): ValueColumn<T> = this as ValueColumn<T>
+
+@PublishedApi
+internal fun AnyCol.asAnyFrameColumn(): FrameColumn<*> = this as FrameColumn<*>
+
+internal fun <T> AnyCol.grouped() = this as ColumnGroup<T>
+
+internal fun <T> ColumnGroup<*>.withDf(newDf: DataFrame<T>) = DataColumn.createColumnGroup(name, newDf)
+
+internal fun <T> DataColumn<T>.assertIsComparable(): DataColumn<T> {
+    if (!type.isSubtypeOf(typeOf<Comparable<*>?>())) {
+        throw RuntimeException("Column '$name' has type '$type' that is not Comparable")
+    }
+    return this
+}
+
+/**
+ * Helper function to perform runtime checks on a [SingleColumn].
+ *
+ * One use case is to check that a column is actually a [ColumnGroup], which is handled by
+ * [org.jetbrains.kotlinx.dataframe.api.ensureIsColumnGroup].
+ */
+internal fun <A> SingleColumn<A>.onResolve(check: (ColumnWithPath<A>?) -> Unit): SingleColumn<A> =
+    object : SingleColumn<A> {
+        override fun resolveSingle(context: ColumnResolutionContext): ColumnWithPath<A>? =
+            this@onResolve.resolveSingle(context).also(check)
+    }
+
+/**
+ * Helper function to perform runtime checks on a [ColumnAccessor].
+ *
+ * One use case is to check that a column is actually a [ValueColumn], which is handled by
+ * [org.jetbrains.kotlinx.dataframe.api.ensureIsValueColumn].
+ */
+internal fun <A> ColumnAccessor<A>.onResolve(check: (ColumnWithPath<*>?) -> Unit): ColumnAccessor<A> =
+    object : ColumnAccessor<A> {
+        override fun <C> get(column: ColumnReference<C>): ColumnAccessor<C> =
+            this@onResolve.get(column).onResolve(check)
+
+        override fun rename(newName: String): ColumnAccessor<A> = this@onResolve.rename(newName).onResolve(check)
+
+        override fun name(): String = this@onResolve.name()
+
+        override fun resolveSingle(context: ColumnResolutionContext): ColumnWithPath<A>? =
+            this@onResolve.resolveSingle(context).also(check)
+    }
+
+internal fun <A> TransformableSingleColumn<A>.onResolve(
+    check: (ColumnWithPath<A>?) -> Unit,
+): TransformableSingleColumn<A> =
+    object : TransformableSingleColumn<A> {
+        override fun resolveSingle(context: ColumnResolutionContext): ColumnWithPath<A>? =
+            this@onResolve.resolveSingle(context).also(check)
+
+        override fun transformResolveSingle(
+            context: ColumnResolutionContext,
+            transformer: ColumnsResolverTransformer,
+        ): ColumnWithPath<A>? = this@onResolve.transformResolveSingle(context, transformer).also(check)
+    }
+
+internal fun <A> ColumnSet<A>.onResolve(check: (List<ColumnWithPath<A>>) -> Unit): ColumnSet<A> =
+    object : ColumnSet<A> {
+        override fun resolve(context: ColumnResolutionContext): List<ColumnWithPath<A>> =
+            this@onResolve.resolve(context).also(check)
+    }
+
+internal fun <A> TransformableColumnSet<A>.onResolve(
+    check: (List<ColumnWithPath<A>>) -> Unit,
+): TransformableColumnSet<A> =
+    object : TransformableColumnSet<A> {
+        override fun resolve(context: ColumnResolutionContext): List<ColumnWithPath<A>> =
+            this@onResolve.resolve(context).also(check)
+
+        override fun transformResolve(
+            context: ColumnResolutionContext,
+            transformer: ColumnsResolverTransformer,
+        ): List<ColumnWithPath<A>> = this@onResolve.transformResolve(context, transformer).also(check)
+    }
+
+/**
+ * Applies a transformation on [this] [SingleColumn] by converting its
+ * single [ColumnWithPath]<[A]> to [List]<[ColumnWithPath]<[B]>] using [converter].
+ * Since [converter] allows you to return multiple columns, the result is turned into a [ColumnSet]<[B]>.
+ */
+internal fun <A, B> SingleColumn<A>.transformSingle(
+    converter: (ColumnWithPath<A>) -> List<ColumnWithPath<B>>,
+): ColumnSet<B> =
+    object : ColumnSet<B> {
+        override fun resolve(context: ColumnResolutionContext): List<ColumnWithPath<B>> =
+            this@transformSingle
+                .resolveSingle(context)
+                ?.let(converter)
+                ?: emptyList()
+    }
+
+/**
+ * Applies a transformation on [this] by converting its [List]<[ColumnWithPath]<[A]>] to [List]<[ColumnWithPath]<[B]>]
+ * using [converter].
+ *
+ * The result can either be used as a normal [ColumnSet]<[B]>,
+ * which resolves [this] and then applies [converter] on the result,
+ *
+ * or it can be used as a [TransformableColumnSet]<[B]>, where a [ColumnsResolverTransformer] can be injected before
+ * the [converter] is applied.
+ */
+internal fun <A, B> ColumnsResolver<A>.transform(
+    converter: (List<ColumnWithPath<A>>) -> List<ColumnWithPath<B>>,
+): TransformableColumnSet<B> =
+    object : TransformableColumnSet<B> {
+        override fun resolve(context: ColumnResolutionContext) =
+            this@transform
+                .resolve(context)
+                .let(converter)
+
+        override fun transformResolve(
+            context: ColumnResolutionContext,
+            transformer: ColumnsResolverTransformer,
+        ): List<ColumnWithPath<B>> =
+            transformer.transform(this@transform)
+                .resolve(context)
+                .let { converter(it as List<ColumnWithPath<A>>) }
+    }
+
+/**
+ * Applies a transformation on [this] [SingleColumn] by converting its
+ * single [ColumnWithPath]<[A]> to [List]<[ColumnWithPath]<[B]>] using [converter] but
+ * also providing the [ColumnResolutionContext] to the converter.
+ *
+ *  Since [converter] allows you to return multiple columns, the result is turned into a [ColumnSet]<[B]>.
+ *
+ * The result can either be used as a normal [ColumnSet]<[B]>,
+ * which resolves [this] and then applies [converter] on the result,
+ */
+internal fun <A, B> SingleColumn<A>.transformSingleWithContext(
+    converter: ColumnResolutionContext.(ColumnWithPath<A>) -> List<ColumnWithPath<B>>,
+): ColumnSet<B> =
+    object : ColumnSet<B> {
+
+        override fun resolve(context: ColumnResolutionContext): List<ColumnWithPath<B>> =
+            this@transformSingleWithContext
+                .resolveSingle(context)
+                ?.let { converter(context, it) }
+                ?: emptyList()
+    }
+
+/**
+ * Applies a transformation on [this] by converting its [List]<[ColumnWithPath]<[A]>] to [List]<[ColumnWithPath]<[B]>]
+ * using [converter], but also providing the [ColumnResolutionContext] to the converter.
+ *
+ * The result can either be used as a normal [ColumnSet]<[B]>,
+ * which resolves [this] and then applies [converter] on the result,
+ *
+ * or it can be used as a [TransformableColumnSet]<[B]>, where a [ColumnsResolverTransformer] can be injected before
+ * the [converter] is applied.
+ */
+internal fun <A, B> ColumnsResolver<A>.transformWithContext(
+    converter: ColumnResolutionContext.(List<ColumnWithPath<A>>) -> List<ColumnWithPath<B>>,
+): TransformableColumnSet<B> =
+    object : TransformableColumnSet<B> {
+        override fun resolve(context: ColumnResolutionContext) =
+            this@transformWithContext
+                .resolve(context)
+                .let { converter(context, it) }
+
+        override fun transformResolve(
+            context: ColumnResolutionContext,
+            transformer: ColumnsResolverTransformer,
+        ): List<ColumnWithPath<B>> =
+            transformer.transform(this@transformWithContext)
+                .resolve(context)
+                .let { converter(context, it as List<ColumnWithPath<A>>) }
+    }
+
+/** Makes sure the right error messages appear when running [List.single] */
+private fun <T> List<ColumnWithPath<T>>.singleImpl(): ColumnWithPath<T> =
+    try {
+        single()
+    } catch (e: NoSuchElementException) {
+        throw NoSuchElementException("ColumnSet is empty")
+    } catch (e: IllegalArgumentException) {
+        throw IllegalArgumentException("ColumnSet contains more than one column")
+    }
+
+/**
+ * Converts [this] [ColumnsResolver] to a [SingleColumn].
+ * [resolveSingle] will return the single column of [this] if there is only one, else it will return throw an exception:
+ * In case of an empty [ColumnsResolver], a [NoSuchElementException] will be thrown.
+ * In case of more than one column, a [IllegalArgumentException] will be thrown.
+ * If the result is used as a [ColumnSet], `null` will be converted to an empty list.
+ */
+internal fun <T> ColumnsResolver<T>.singleImpl(): SingleColumn<T> =
+    object : SingleColumn<T> {
+        override fun resolveSingle(context: ColumnResolutionContext): ColumnWithPath<T> =
+            this@singleImpl.resolve(context).singleImpl()
+    }
+
+/**
+ * Same as [singleImpl], however, it passes any [ColumnsResolverTransformer] back to [this] if it is supplied.
+ */
+internal fun <T> TransformableColumnSet<T>.singleWithTransformerImpl(): TransformableSingleColumn<T> =
+    object : TransformableSingleColumn<T> {
+        override fun resolveSingle(context: ColumnResolutionContext): ColumnWithPath<T> =
+            this@singleWithTransformerImpl.resolve(context).singleImpl()
+
+        override fun transformResolveSingle(
+            context: ColumnResolutionContext,
+            transformer: ColumnsResolverTransformer,
+        ): ColumnWithPath<T> =
+            this@singleWithTransformerImpl.transformResolve(
+                context = context,
+                transformer = transformer,
+            ).singleImpl()
+    }
+
+/**
+ * Converts [this] [ColumnsResolver] to a [SingleColumn].
+ * [resolveSingle] will return the single column of [this] if there is only one, else it will return `null`.
+ * If the result used as a [ColumnSet], `null` will be converted to an empty list.
+ */
+internal fun <T> ColumnsResolver<T>.singleOrNullImpl(): SingleColumn<T> =
+    object : SingleColumn<T> {
+        override fun resolveSingle(context: ColumnResolutionContext): ColumnWithPath<T>? =
+            this@singleOrNullImpl.resolve(context).singleOrNull()
+    }
+
+/**
+ * Same as [singleOrNullImpl], however, it passes any [ColumnsResolverTransformer] back to [this] if it is supplied.
+ */
+internal fun <T> TransformableColumnSet<T>.singleOrNullWithTransformerImpl(): TransformableSingleColumn<T> =
+    object : TransformableSingleColumn<T> {
+        override fun resolveSingle(context: ColumnResolutionContext): ColumnWithPath<T>? =
+            this@singleOrNullWithTransformerImpl.resolve(context).singleOrNull()
+
+        override fun transformResolveSingle(
+            context: ColumnResolutionContext,
+            transformer: ColumnsResolverTransformer,
+        ): ColumnWithPath<T>? =
+            this@singleOrNullWithTransformerImpl.transformResolve(
+                context = context,
+                transformer = transformer,
+            ).singleOrNull()
+    }
+
+internal fun <T> ColumnsResolver<T>.getAt(index: Int): SingleColumn<T> =
+    object : SingleColumn<T> {
+        override fun resolveSingle(context: ColumnResolutionContext): ColumnWithPath<T> =
+            this@getAt.resolve(context).let {
+                try {
+                    it[index]
+                } catch (e: IndexOutOfBoundsException) {
+                    throw IndexOutOfBoundsException("ColumnSet has no column at index $index")
+                }
+            }
+    }
+
+internal fun <T> ColumnSet<T>.getAtOrNull(index: Int): SingleColumn<T> =
+    object : SingleColumn<T> {
+        override fun resolveSingle(context: ColumnResolutionContext): ColumnWithPath<T>? =
+            this@getAtOrNull
+                .resolve(context)
+                .getOrNull(index)
+    }
+
+internal fun ColumnSet<*>.getChildrenAt(index: Int): ColumnSet<*> = transform { it.mapNotNull { it.getCol(index) } }
+
+internal fun <C> ColumnsContainer<*>.getColumn(name: String, policy: UnresolvedColumnsPolicy) =
+    getColumnOrNull(name)?.cast()
+        ?: when (policy) {
+            UnresolvedColumnsPolicy.Fail ->
+                error("Column not found: $name")
+
+            UnresolvedColumnsPolicy.Skip -> null
+
+            UnresolvedColumnsPolicy.Create -> DataColumn.empty().cast<C>()
+        }
+
+internal fun <C> ColumnsContainer<*>.getColumn(path: ColumnPath, policy: UnresolvedColumnsPolicy) =
+    getColumnOrNull(path)?.cast()
+        ?: when (policy) {
+            UnresolvedColumnsPolicy.Fail ->
+                error("Column not found: '${path.joinToString()}'")
+
+            UnresolvedColumnsPolicy.Skip -> null
+
+            UnresolvedColumnsPolicy.Create -> DataColumn.empty().cast<C>()
+        }
+
+/**
+ * Simplifies structure by removing columns that are already present in
+ * column groups in [this].
+ *
+ * A.k.a. it gets a sub-list of columns that are roots of the trees of columns.
+ *
+ * Note: this doesn't merge similarly called groups into one, nor does it insert columns into groups if they weren't
+ * so already.
+ */
+internal fun <T> List<ColumnWithPath<T>>.simplify(): List<ColumnWithPath<T>> {
+    val root = TreeNode.createRoot<ColumnWithPath<T>?>(data = null)
+    this.forEach { root.put(it.path, it) }
+    return root.topmostChildren { it.data != null }.map { it.data!! }
+}
+
+/**
+ * Returns a new list of column paths, except the ones inside [columns].
+ * NOTE: The structure is not kept the same; if a column is removed, its parent will be removed as well, and
+ * all its siblings will be lifted out of the group. This also happens if a column is "removed" that does
+ * not exist in [this].
+ */
+internal fun List<ColumnWithPath<*>>.allColumnsExceptAndUnpack(
+    columns: Iterable<ColumnWithPath<*>>,
+): List<ColumnWithPath<*>> {
+    if (isEmpty()) return emptyList()
+    val fullTree = collectTree()
+    columns.forEach {
+        var node = fullTree.getOrPut(it.path).asNullable()
+        node?.allChildren()?.forEach { it.data = null }
+        while (node != null) {
+            node.data = null
+            node = node.parent
+        }
+    }
+    val subtrees = fullTree.topmostChildren { it.data != null }
+    return subtrees.map { it.data!!.addPath(it.pathFromRoot()) }
+}
+
+/**
+ * Returns a new list of column paths, except the ones inside [columns].
+ * NOTE: ColumnGroups are adapted to keep their structure. If a column inside a column group is excepted, it will
+ * be removed from the group.
+ * Empty groups will be removed if [removeEmptyGroups]` == true`
+ */
+internal fun List<ColumnWithPath<*>>.allColumnsExceptKeepingStructure(
+    columns: Iterable<ColumnWithPath<*>>,
+    removeEmptyGroups: Boolean = true,
+): List<ColumnWithPath<*>> {
+    if (isEmpty()) return emptyList()
+    val fullTree = collectTree()
+    for (columnToExcept in columns) {
+        // grab the node representing the column from the tree
+        val nodeToExcept = fullTree.getOrPut(columnToExcept.path).asNullable()
+        if (nodeToExcept != null) {
+            // remove the children from the node (if it's a column group) and remove its data (the column itself)
+            nodeToExcept.allChildren().forEach { it.data = null }
+            nodeToExcept.data = null
+
+            // we need to update the data of the parent node(s) to reflect the removal of the column
+            if (nodeToExcept.parent != null) {
+                // we grab the data of the parent node, which should be a column group
+                // treat it as a DF to remove the column to except from it and
+                // convert it back to a column group
+                val current = nodeToExcept.parent.data as ColumnGroup<*>? ?: continue
+                val adjustedCurrent = current
+                    .remove(nodeToExcept.name)
+                    .asColumnGroup(current.name)
+                    .addPath(current.path())
+
+                // remove the group if it's empty and removeEmptyGroups is true
+                // else, simply update the parent's data with the adjusted column group
+                nodeToExcept.parent.data =
+                    if (adjustedCurrent.cols().isEmpty() && removeEmptyGroups) {
+                        null
+                    } else {
+                        adjustedCurrent
+                    }
+
+                // now we update the parent's parents recursively with new column group instances
+                var parent = nodeToExcept.parent.parent
+
+                @Suppress("UNNECESSARY_NOT_NULL_ASSERTION")
+                var currentNode = nodeToExcept.parent!!
+                while (parent != null) {
+                    val parentData = parent.data as ColumnGroup<*>? ?: break
+                    parent.data = parentData
+                        .replace(currentNode.name).with { currentNode.data!! }
+                        .asColumnGroup(parentData.name)
+                        .addPath(parentData.path())
+
+                    currentNode = parent
+                    parent = parent.parent
+                }
+            }
+        }
+    }
+    val subtrees = fullTree.topmostChildren { it.data != null }
+    return subtrees.map { it.data!!.addPath(it.pathFromRoot()) }
+}
+
+internal fun KType.toColumnKind(): ColumnKind =
+    jvmErasure.let {
+        when (it) {
+            DataFrame::class -> ColumnKind.Frame
+            DataRow::class -> ColumnKind.Group
+            else -> ColumnKind.Value
+        }
+    }
+
+internal fun <C> ColumnsResolver<C>.resolve(
+    df: DataFrame<*>,
+    unresolvedColumnsPolicy: UnresolvedColumnsPolicy = UnresolvedColumnsPolicy.Fail,
+) = resolve(ColumnResolutionContext(df, unresolvedColumnsPolicy))
+
+internal fun <C> SingleColumn<C>.resolveSingle(
+    df: DataFrame<*>,
+    unresolvedColumnsPolicy: UnresolvedColumnsPolicy = UnresolvedColumnsPolicy.Fail,
+): ColumnWithPath<C>? = resolveSingle(ColumnResolutionContext(df, unresolvedColumnsPolicy))
+
+internal fun AnyBaseCol.unbox(): AnyCol =
+    when (this) {
+        is ColumnWithPath<*> -> data.unbox()
+        is ColumnWithParent<*> -> source.unbox()
+        is ForceResolvedColumn<*> -> source.unbox()
+        else -> this as AnyCol
+    }
+
+internal fun AnyCol.isMissingColumn() = this is MissingDataColumn
+
+internal fun <T> ColumnGroup<T>.extractDataFrame(): DataFrame<T> = DataFrameImpl(columns(), nrow)
+
+internal fun <T> BaseColumn<T>.addParent(parent: ColumnGroup<*>) = (this as DataColumnInternal<T>).addParent(parent)
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/ValueColumnImpl.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/ValueColumnImpl.kt
new file mode 100644
index 000000000..f758360d1
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/ValueColumnImpl.kt
@@ -0,0 +1,73 @@
+package org.jetbrains.kotlinx.dataframe.impl.columns
+
+import org.jetbrains.kotlinx.dataframe.AnyRow
+import org.jetbrains.kotlinx.dataframe.DataColumn
+import org.jetbrains.kotlinx.dataframe.columns.ColumnGroup
+import org.jetbrains.kotlinx.dataframe.columns.ColumnResolutionContext
+import org.jetbrains.kotlinx.dataframe.columns.ValueColumn
+import kotlin.reflect.KType
+import kotlin.reflect.full.withNullability
+
+internal open class ValueColumnImpl<T>(
+    values: List<T>,
+    name: String,
+    type: KType,
+    val defaultValue: T? = null,
+    distinct: Lazy<Set<T>>? = null,
+) : DataColumnImpl<T>(values, name, type, distinct),
+    ValueColumn<T> {
+
+    override fun distinct() = ValueColumnImpl(toSet().toList(), name, type, defaultValue, distinct)
+
+    override fun rename(newName: String) = ValueColumnImpl(values, newName, type, defaultValue, distinct)
+
+    override fun changeType(type: KType) = ValueColumnImpl(values, name, type, defaultValue, distinct)
+
+    override fun addParent(parent: ColumnGroup<*>): DataColumn<T> = ValueColumnWithParent(parent, this)
+
+    override fun createWithValues(values: List<T>, hasNulls: Boolean?): ValueColumn<T> {
+        val nulls = hasNulls ?: values.any { it == null }
+        return DataColumn.createValueColumn(name, values, type.withNullability(nulls))
+    }
+
+    override fun get(indices: Iterable<Int>): ValueColumn<T> {
+        var nullable = false
+        val newValues = indices.map {
+            val value = values[it]
+            if (value == null) nullable = true
+            value
+        }
+        return createWithValues(newValues, nullable)
+    }
+
+    override fun get(columnName: String) =
+        throw UnsupportedOperationException("Can not get nested column '$columnName' from ValueColumn '$name'")
+
+    override operator fun get(range: IntRange): ValueColumn<T> = super<DataColumnImpl>.get(range) as ValueColumn<T>
+
+    override fun defaultValue() = defaultValue
+
+    override fun forceResolve() = ResolvingValueColumn(this)
+}
+
+internal class ResolvingValueColumn<T>(override val source: ValueColumn<T>) :
+    ValueColumn<T> by source,
+    ForceResolvedColumn<T> {
+
+    override fun resolve(context: ColumnResolutionContext) = super<ValueColumn>.resolve(context)
+
+    override fun resolveSingle(context: ColumnResolutionContext) =
+        context.df.getColumn<T>(source.name(), context.unresolvedColumnsPolicy)?.addPath()
+
+    override fun getValue(row: AnyRow) = super<ValueColumn>.getValue(row)
+
+    override fun getValueOrNull(row: AnyRow) = super<ValueColumn>.getValueOrNull(row)
+
+    override fun rename(newName: String) = ResolvingValueColumn(source.rename(newName))
+
+    override fun toString(): String = source.toString()
+
+    override fun equals(other: Any?) = source.checkEquals(other)
+
+    override fun hashCode(): Int = source.hashCode()
+}
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/ValueColumnWithParent.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/ValueColumnWithParent.kt
new file mode 100644
index 000000000..974cfb433
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/ValueColumnWithParent.kt
@@ -0,0 +1,32 @@
+package org.jetbrains.kotlinx.dataframe.impl.columns
+
+import org.jetbrains.kotlinx.dataframe.columns.ColumnGroup
+import org.jetbrains.kotlinx.dataframe.columns.ColumnResolutionContext
+import org.jetbrains.kotlinx.dataframe.columns.ValueColumn
+import kotlin.reflect.KType
+
+internal class ValueColumnWithParent<T>(override val parent: ColumnGroup<*>, override val source: ValueColumn<T>) :
+    ColumnWithParent<T>,
+    ValueColumn<T> by source,
+    DataColumnInternal<T> {
+
+    override fun equals(other: Any?) = source.checkEquals(other)
+
+    override fun hashCode() = source.hashCode()
+
+    override fun path() = super<ColumnWithParent>.path()
+
+    override fun resolve(context: ColumnResolutionContext) = super<ColumnWithParent>.resolve(context)
+
+    override fun resolveSingle(context: ColumnResolutionContext) = super<ColumnWithParent>.resolveSingle(context)
+
+    override fun rename(newName: String): ValueColumnWithParent<T> =
+        ValueColumnWithParent(parent, source.rename(newName))
+
+    override fun forceResolve() = ResolvingValueColumn(this)
+
+    override fun changeType(type: KType) =
+        ValueColumnWithParent(parent, source.internal().changeType(type).asValueColumn())
+
+    override fun addParent(parent: ColumnGroup<*>) = source.addParent(parent)
+}
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/ValueColumnWithPathImpl.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/ValueColumnWithPathImpl.kt
new file mode 100644
index 000000000..34e9cbd88
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/ValueColumnWithPathImpl.kt
@@ -0,0 +1,24 @@
+package org.jetbrains.kotlinx.dataframe.impl.columns
+
+import org.jetbrains.kotlinx.dataframe.columns.ColumnPath
+import org.jetbrains.kotlinx.dataframe.columns.ColumnResolutionContext
+import org.jetbrains.kotlinx.dataframe.columns.ColumnWithPath
+import org.jetbrains.kotlinx.dataframe.columns.ValueColumn
+
+internal class ValueColumnWithPathImpl<T> internal constructor(
+    override val data: ValueColumn<T>,
+    override val path: ColumnPath,
+) : ColumnWithPath<T>,
+    ValueColumn<T> by data {
+
+    override fun resolveSingle(context: ColumnResolutionContext): ColumnWithPath<T> = this
+
+    override fun rename(newName: String) =
+        if (newName == name()) {
+            this
+        } else {
+            ValueColumnWithPathImpl(data.rename(newName), path.dropLast(1) + newName)
+        }
+
+    override fun path() = path
+}
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/constructors.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/constructors.kt
new file mode 100644
index 000000000..bb9fcc8ab
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/constructors.kt
@@ -0,0 +1,312 @@
+package org.jetbrains.kotlinx.dataframe.impl.columns
+
+import org.jetbrains.kotlinx.dataframe.AnyCol
+import org.jetbrains.kotlinx.dataframe.AnyFrame
+import org.jetbrains.kotlinx.dataframe.AnyRow
+import org.jetbrains.kotlinx.dataframe.ColumnsContainer
+import org.jetbrains.kotlinx.dataframe.ColumnsSelector
+import org.jetbrains.kotlinx.dataframe.DataColumn
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.DataRow
+import org.jetbrains.kotlinx.dataframe.Selector
+import org.jetbrains.kotlinx.dataframe.api.AddDataRow
+import org.jetbrains.kotlinx.dataframe.api.AddExpression
+import org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl
+import org.jetbrains.kotlinx.dataframe.api.Infer
+import org.jetbrains.kotlinx.dataframe.api.PivotColumnsSelector
+import org.jetbrains.kotlinx.dataframe.api.PivotDsl
+import org.jetbrains.kotlinx.dataframe.api.SortColumnsSelector
+import org.jetbrains.kotlinx.dataframe.api.SortDsl
+import org.jetbrains.kotlinx.dataframe.api.asDataColumn
+import org.jetbrains.kotlinx.dataframe.api.cast
+import org.jetbrains.kotlinx.dataframe.api.concat
+import org.jetbrains.kotlinx.dataframe.api.dataFrameOf
+import org.jetbrains.kotlinx.dataframe.api.indices
+import org.jetbrains.kotlinx.dataframe.api.toColumnOf
+import org.jetbrains.kotlinx.dataframe.api.toDataFrame
+import org.jetbrains.kotlinx.dataframe.columns.ColumnResolutionContext
+import org.jetbrains.kotlinx.dataframe.columns.ColumnSet
+import org.jetbrains.kotlinx.dataframe.columns.ColumnWithPath
+import org.jetbrains.kotlinx.dataframe.columns.ColumnsResolver
+import org.jetbrains.kotlinx.dataframe.columns.toColumnsSetOf
+import org.jetbrains.kotlinx.dataframe.impl.DataFrameReceiver
+import org.jetbrains.kotlinx.dataframe.impl.DataRowImpl
+import org.jetbrains.kotlinx.dataframe.impl.asList
+import org.jetbrains.kotlinx.dataframe.impl.guessValueType
+import org.jetbrains.kotlinx.dataframe.impl.replaceGenericTypeParametersWithUpperbound
+import org.jetbrains.kotlinx.dataframe.index
+import org.jetbrains.kotlinx.dataframe.nrow
+import kotlin.reflect.KClass
+import kotlin.reflect.KType
+import kotlin.reflect.full.withNullability
+
+// region create DataColumn
+
+internal class AddDataRowImpl<T>(index: Int, owner: DataFrame<T>, private val container: List<*>) :
+    DataRowImpl<T>(index, owner),
+    AddDataRow<T> {
+
+    override fun <C> AnyRow.newValue() = container[index] as C
+}
+
+@PublishedApi
+internal fun <T, R> ColumnsContainer<T>.newColumn(
+    type: KType,
+    name: String = "",
+    infer: Infer = Infer.Nulls,
+    expression: AddExpression<T, R>,
+): DataColumn<R> {
+    val df = this as? DataFrame<T> ?: dataFrameOf(columns()).cast()
+    val (nullable, values) = computeValues(df, expression)
+    return when (infer) {
+        Infer.Nulls -> DataColumn.create(
+            name = name,
+            values = values,
+            type = type.withNullability(nullable).replaceGenericTypeParametersWithUpperbound(),
+            infer = Infer.None,
+        )
+
+        Infer.Type -> DataColumn.createWithTypeInference(
+            name = name,
+            values = values,
+            nullable = nullable,
+        )
+
+        Infer.None -> DataColumn.create(
+            name = name,
+            values = values,
+            type = type.replaceGenericTypeParametersWithUpperbound(),
+            infer = Infer.None,
+        )
+    }
+}
+
+@PublishedApi
+internal fun <T, R> ColumnsContainer<T>.newColumnWithActualType(
+    name: String,
+    expression: AddExpression<T, R>,
+): DataColumn<R> {
+    val (_, values) = computeValues(this as DataFrame<T>, expression)
+    return guessColumnType(name, values)
+}
+
+internal fun <T, R> computeValues(df: DataFrame<T>, expression: AddExpression<T, R>): Pair<Boolean, List<R>> {
+    var nullable = false
+    val list = ArrayList<R>(df.nrow)
+    df.indices().forEach {
+        val row = AddDataRowImpl(it, df, list)
+        val value = expression(row, row)
+        if (value == null) nullable = true
+        list.add(value)
+    }
+    return nullable to list
+}
+
+@Suppress("UNCHECKED_CAST")
+@PublishedApi
+internal fun <T> createColumn(values: Iterable<T>, suggestedType: KType, guessType: Boolean = false): DataColumn<T> =
+    when {
+        // values is a non-empty list of AnyRows
+        values.any() && values.all { it is AnyRow } ->
+            DataColumn.createColumnGroup(
+                name = "",
+                df = (values as Iterable<AnyRow>).toDataFrame(),
+            ).asDataColumn().cast()
+
+        // values is a non-empty list of DataColumns
+        values.any() && values.all { it is AnyCol } ->
+            DataColumn.createColumnGroup(
+                name = "",
+                df = (values as Iterable<AnyCol>).toDataFrame(),
+            ).asDataColumn().cast()
+
+        // values is a non-empty list of DataFrames and nulls
+        // (but not just nulls; we cannot assume that should create a FrameColumn)
+        values.any() && values.all { it is AnyFrame? } && !values.all { it == null } ->
+            DataColumn.createFrameColumn(
+                name = "",
+                groups = values.map { it as? AnyFrame ?: DataFrame.empty() },
+            ).asDataColumn().cast()
+
+        guessType ->
+            guessColumnType(
+                name = "",
+                values = values.asList(),
+                suggestedType = suggestedType,
+                suggestedTypeIsUpperBound = true,
+            ).cast()
+
+        else ->
+            DataColumn.createValueColumn(
+                name = "",
+                values = values.toList(),
+                type = suggestedType,
+            )
+    }
+
+// endregion
+
+// region create Columns
+
+internal fun <C> createColumnSet(
+    resolver: (context: ColumnResolutionContext) -> List<ColumnWithPath<C>>,
+): ColumnSet<C> =
+    object : ColumnSet<C> {
+        override fun resolve(context: ColumnResolutionContext) = resolver(context)
+    }
+
+internal fun <C> createTransformableColumnSet(
+    resolver: (context: ColumnResolutionContext) -> List<ColumnWithPath<C>>,
+    transformResolve: (
+        context: ColumnResolutionContext,
+        transformer: ColumnsResolverTransformer,
+    ) -> List<ColumnWithPath<C>>,
+): TransformableColumnSet<C> =
+    object : TransformableColumnSet<C> {
+        override fun resolve(context: ColumnResolutionContext) = resolver(context)
+
+        override fun transformResolve(
+            context: ColumnResolutionContext,
+            transformer: ColumnsResolverTransformer,
+        ): List<ColumnWithPath<C>> = transformResolve(context, transformer)
+    }
+
+// region toColumnSet
+
+// region DSL
+
+internal fun <TD, T : DataFrame<TD>, C> Selector<T, ColumnsResolver<C>>.toColumnSet(
+    createReceiver: (ColumnResolutionContext) -> T,
+): ColumnSet<C> =
+    createColumnSet {
+        val receiver = createReceiver(it)
+        val columnSet = this(receiver, receiver)
+        columnSet.resolve(receiver, it.unresolvedColumnsPolicy)
+    }
+
+@JvmName("toColumnSetForPivot")
+internal fun <T, C> PivotColumnsSelector<T, C>.toColumnSet(): ColumnSet<C> =
+    toColumnSet {
+        object : DataFrameReceiver<T>(it.df.cast(), it.unresolvedColumnsPolicy), PivotDsl<T> {}
+    }
+
+@JvmName("toColumnSetForSort")
+internal fun <T, C> SortColumnsSelector<T, C>.toColumnSet(): ColumnSet<C> =
+    toColumnSet {
+        object : DataFrameReceiver<T>(it.df.cast(), it.unresolvedColumnsPolicy), SortDsl<T> {}
+    }
+
+internal fun <T, C> ColumnsSelector<T, C>.toColumnSet(): ColumnSet<C> =
+    toColumnSet {
+        object : DataFrameReceiver<T>(it.df.cast(), it.unresolvedColumnsPolicy), ColumnsSelectionDsl<T> {}
+    }
+
+// endregion
+
+// endregion
+
+// region toComparableColumns
+
+internal fun Array<out String>.toComparableColumns() = toColumnsSetOf<Comparable<Any?>>()
+
+internal fun String.toComparableColumn() = toColumnOf<Comparable<Any?>>()
+
+// endregion
+
+internal fun Array<out String>.toNumberColumns() = toColumnsSetOf<Number>()
+
+// endregion
+
+internal fun <T> guessColumnType(name: String, values: List<T>) = guessColumnType(name, values, null)
+
+@PublishedApi
+internal fun <T> guessColumnType(
+    name: String,
+    values: List<T>,
+    suggestedType: KType? = null,
+    suggestedTypeIsUpperBound: Boolean = false,
+    defaultValue: T? = null,
+    nullable: Boolean? = null,
+): DataColumn<T> {
+    val detectType = suggestedType == null || suggestedTypeIsUpperBound
+    val type = if (detectType) {
+        guessValueType(
+            values = values.asSequence(),
+            upperBound = suggestedType,
+            listifyValues = false,
+        )
+    } else {
+        suggestedType!!
+    }
+
+    return when (type.classifier!! as KClass<*>) {
+        DataRow::class -> {
+            val df = values.map { (it as AnyRow?)?.toDataFrame() ?: DataFrame.empty(1) }.concat()
+            DataColumn.createColumnGroup(name, df).asDataColumn().cast()
+        }
+
+        DataFrame::class -> {
+            val frames = values.map {
+                when (it) {
+                    null -> DataFrame.empty()
+                    is AnyFrame -> it
+                    is AnyRow -> it.toDataFrame()
+                    is List<*> -> (it as List<AnyRow>).toDataFrame()
+                    else -> throw IllegalStateException()
+                }
+            }
+            DataColumn.createFrameColumn(name, frames).asDataColumn().cast()
+        }
+
+        List::class -> {
+            val nullable = type.isMarkedNullable
+            var isListOfRows: Boolean? = null
+            val lists = values.map {
+                when (it) {
+                    null -> if (nullable) null else emptyList()
+
+                    is List<*> -> {
+                        if (isListOfRows != false && it.isNotEmpty()) isListOfRows = it.all { it is AnyRow }
+                        it
+                    }
+
+                    else -> { // if !detectType and suggestedType is a list, we wrap the values in lists
+                        if (isListOfRows != false) isListOfRows = it is AnyRow
+                        listOf(it)
+                    }
+                }
+            }
+            if (isListOfRows == true) {
+                val frames = lists.map {
+                    if (it == null) {
+                        DataFrame.empty()
+                    } else {
+                        (it as List<AnyRow>).concat()
+                    }
+                }
+                DataColumn.createFrameColumn(name, frames).cast()
+            } else {
+                DataColumn.createValueColumn(name, lists, type, defaultValue = defaultValue).cast()
+            }
+        }
+
+        else -> {
+            if (nullable == null) {
+                DataColumn.createValueColumn(
+                    name = name,
+                    values = values,
+                    type = type,
+                    infer = if (detectType) Infer.None else Infer.Nulls,
+                    defaultValue = defaultValue,
+                )
+            } else {
+                DataColumn.createValueColumn(
+                    name = name,
+                    values = values,
+                    type = type.withNullability(nullable),
+                    defaultValue = defaultValue,
+                )
+            }
+        }
+    }
+}
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/missing/MissingColumnGroup.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/missing/MissingColumnGroup.kt
new file mode 100644
index 000000000..57535c7a3
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/missing/MissingColumnGroup.kt
@@ -0,0 +1,78 @@
+package org.jetbrains.kotlinx.dataframe.impl.columns.missing
+
+import org.jetbrains.kotlinx.dataframe.AnyCol
+import org.jetbrains.kotlinx.dataframe.ColumnSelector
+import org.jetbrains.kotlinx.dataframe.ColumnsContainer
+import org.jetbrains.kotlinx.dataframe.DataRow
+import org.jetbrains.kotlinx.dataframe.aggregation.AggregateGroupedBody
+import org.jetbrains.kotlinx.dataframe.api.asDataColumn
+import org.jetbrains.kotlinx.dataframe.api.cast
+import org.jetbrains.kotlinx.dataframe.api.name
+import org.jetbrains.kotlinx.dataframe.columns.ColumnPath
+import org.jetbrains.kotlinx.dataframe.columns.ColumnReference
+import org.jetbrains.kotlinx.dataframe.columns.ColumnResolutionContext
+import org.jetbrains.kotlinx.dataframe.columns.ColumnWithPath
+import org.jetbrains.kotlinx.dataframe.columns.UnresolvedColumnsPolicy
+import org.jetbrains.kotlinx.dataframe.impl.columns.DataColumnGroup
+import org.jetbrains.kotlinx.dataframe.impl.columns.addPath
+import kotlin.reflect.KProperty
+import kotlin.reflect.KType
+
+internal class MissingColumnGroup<T>(val path: ColumnPath, val host: ColumnsContainer<*>) :
+    MissingDataColumn<DataRow<T>>(),
+    DataColumnGroup<T> {
+
+    override fun getColumnOrNull(name: String) = MissingColumnGroup<Any?>(path + name, host)
+
+    override fun getColumnOrNull(index: Int) = MissingColumnGroup<Any?>(path + "", host)
+
+    override fun columnsCount(): Int = 0
+
+    override fun get(index: Int) = throw UnsupportedOperationException()
+
+    override fun get(columnName: String) = throw UnsupportedOperationException()
+
+    override fun rowsCount(): Int = 0
+
+    override fun columns(): List<AnyCol> = emptyList()
+
+    override fun columnNames(): List<String> = emptyList()
+
+    override fun columnTypes(): List<KType> = emptyList()
+
+    override fun getColumnIndex(name: String) = -1
+
+    override fun kind() = super.kind()
+
+    override fun get(firstIndex: Int, vararg otherIndices: Int) = throw UnsupportedOperationException()
+
+    override fun distinct() = throw UnsupportedOperationException()
+
+    override fun <R> aggregate(body: AggregateGroupedBody<T, R>) = throw UnsupportedOperationException()
+
+    override fun <R> getColumnOrNull(column: ColumnReference<R>) =
+        MissingColumnGroup<Any>(path + column.name(), host).asDataColumn().cast<R>()
+
+    override fun <R> getColumnOrNull(column: KProperty<R>) =
+        MissingColumnGroup<Any>(path + column.name, host).asDataColumn().cast<R>()
+
+    override fun getColumnOrNull(path: ColumnPath) = MissingColumnGroup<Any?>(this.path + path, host)
+
+    override fun <R> getColumnOrNull(column: ColumnSelector<T, R>) =
+        MissingColumnGroup<Any>(path + "", host).asDataColumn().cast<R>()
+
+    override fun name(): String = path.name
+
+    override fun resolveSingle(context: ColumnResolutionContext): ColumnWithPath<DataRow<T>>? =
+        when (context.unresolvedColumnsPolicy) {
+            UnresolvedColumnsPolicy.Skip -> null
+            UnresolvedColumnsPolicy.Create -> this.addPath(path)
+            UnresolvedColumnsPolicy.Fail -> error("Failed to resolve column $path")
+        }
+
+    override fun containsColumn(name: String): Boolean = false
+
+    override fun containsColumn(path: ColumnPath): Boolean = false
+
+    override fun contains(value: DataRow<T>) = false
+}
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/missing/MissingDataColumn.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/missing/MissingDataColumn.kt
new file mode 100644
index 000000000..b6cf482c0
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/missing/MissingDataColumn.kt
@@ -0,0 +1,36 @@
+package org.jetbrains.kotlinx.dataframe.impl.columns.missing
+
+import org.jetbrains.kotlinx.dataframe.columns.ColumnGroup
+import org.jetbrains.kotlinx.dataframe.impl.columns.DataColumnInternal
+import kotlin.reflect.KType
+
+internal abstract class MissingDataColumn<T> : DataColumnInternal<T> {
+
+    override fun values() = throw UnsupportedOperationException()
+
+    override fun type() = throw UnsupportedOperationException()
+
+    override fun countDistinct() = throw UnsupportedOperationException()
+
+    override fun size() = throw UnsupportedOperationException()
+
+    override fun get(index: Int) = throw UnsupportedOperationException()
+
+    override fun defaultValue() = throw UnsupportedOperationException()
+
+    override fun get(columnName: String) = throw UnsupportedOperationException()
+
+    override fun get(indices: Iterable<Int>) = throw UnsupportedOperationException()
+
+    override fun toSet() = throw UnsupportedOperationException()
+
+    override fun changeType(type: KType) = throw UnsupportedOperationException()
+
+    override fun rename(newName: String) = throw UnsupportedOperationException()
+
+    override fun addParent(parent: ColumnGroup<*>) = throw UnsupportedOperationException()
+
+    override fun forceResolve() = throw UnsupportedOperationException()
+
+    override fun get(range: IntRange) = throw UnsupportedOperationException()
+}
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/tree/ColumnPosition.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/tree/ColumnPosition.kt
new file mode 100644
index 000000000..d589ccbd2
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/tree/ColumnPosition.kt
@@ -0,0 +1,9 @@
+package org.jetbrains.kotlinx.dataframe.impl.columns.tree
+
+import org.jetbrains.kotlinx.dataframe.AnyCol
+
+internal data class ColumnPosition(
+    override val originalIndex: Int,
+    override var wasRemoved: Boolean,
+    var column: AnyCol?,
+) : ReferenceData
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/tree/ReadonlyTreeNode.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/tree/ReadonlyTreeNode.kt
new file mode 100644
index 000000000..ffa4aad74
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/tree/ReadonlyTreeNode.kt
@@ -0,0 +1,14 @@
+package org.jetbrains.kotlinx.dataframe.impl.columns.tree
+
+internal interface ReadonlyTreeNode<out T> {
+
+    val name: String
+    val depth: Int
+    val data: T
+    val parent: ReadonlyTreeNode<T>?
+    val children: List<ReadonlyTreeNode<T>>
+
+    fun getRoot(): ReadonlyTreeNode<T>?
+
+    operator fun get(childName: String): ReadonlyTreeNode<T>?
+}
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/tree/ReferenceData.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/tree/ReferenceData.kt
new file mode 100644
index 000000000..24207de5b
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/tree/ReferenceData.kt
@@ -0,0 +1,6 @@
+package org.jetbrains.kotlinx.dataframe.impl.columns.tree
+
+internal interface ReferenceData {
+    val originalIndex: Int
+    val wasRemoved: Boolean
+}
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/tree/TreeNode.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/tree/TreeNode.kt
new file mode 100644
index 000000000..4492052aa
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/tree/TreeNode.kt
@@ -0,0 +1,75 @@
+package org.jetbrains.kotlinx.dataframe.impl.columns.tree
+
+import org.jetbrains.kotlinx.dataframe.columns.ColumnPath
+
+internal class TreeNode<T>(
+    override var name: String,
+    override val depth: Int,
+    override var data: T,
+    override val parent: TreeNode<T>? = null,
+) : ReadonlyTreeNode<T> {
+
+    companion object {
+        fun <T> createRoot(data: T) = TreeNode<T>("", 0, data)
+    }
+
+    private val myChildren = mutableListOf<TreeNode<T>>()
+    private val childrenMap = mutableMapOf<String, TreeNode<T>>()
+
+    override val children: List<TreeNode<T>>
+        get() = myChildren
+
+    override fun getRoot(): TreeNode<T> = parent?.getRoot() ?: this
+
+    fun contains(childName: String) = childrenMap.containsKey(childName)
+
+    override operator fun get(childName: String) = childrenMap[childName]
+
+    fun pathFromRoot(): ColumnPath {
+        val path = mutableListOf<String>()
+        var node: TreeNode<T>? = this
+        while (node?.parent != null) {
+            path.add(node.name)
+            node = node.parent
+        }
+        path.reverse()
+        return ColumnPath(path)
+    }
+
+    fun addChild(childName: String, childData: T): TreeNode<T> {
+        val node = TreeNode(childName, depth + 1, childData, this)
+        myChildren.add(node)
+        childrenMap[childName] = node
+        return node
+    }
+
+    fun getOrPut(childName: String, createData: () -> T): TreeNode<T> {
+        childrenMap[childName]?.let { return it }
+        return addChild(childName, createData())
+    }
+
+    /**
+     * Traverses the tree in depth-first order and returns all nodes that satisfy [yieldCondition].
+     * If [enterCondition] returns false for a node, its children are not traversed.
+     * By default, all nodes are traversed and all nodes are returned.
+     */
+    fun allChildren(
+        enterCondition: (TreeNode<T>) -> Boolean = { true },
+        yieldCondition: (TreeNode<T>) -> Boolean = { true },
+    ): List<TreeNode<T>> {
+        val result = mutableListOf<TreeNode<T>>()
+
+        fun traverse(node: TreeNode<T>) {
+            if (yieldCondition(node)) {
+                result.add(node)
+            }
+            if (enterCondition(node)) {
+                node.children.forEach {
+                    traverse(it)
+                }
+            }
+        }
+        traverse(this)
+        return result
+    }
+}
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/tree/Utils.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/tree/Utils.kt
new file mode 100644
index 000000000..0db48d0ed
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/tree/Utils.kt
@@ -0,0 +1,162 @@
+package org.jetbrains.kotlinx.dataframe.impl.columns.tree
+
+import org.jetbrains.kotlinx.dataframe.AnyCol
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.api.asColumnGroup
+import org.jetbrains.kotlinx.dataframe.api.isColumnGroup
+import org.jetbrains.kotlinx.dataframe.columns.ColumnPath
+import org.jetbrains.kotlinx.dataframe.columns.ColumnWithPath
+import org.jetbrains.kotlinx.dataframe.impl.columns.addPath
+import org.jetbrains.kotlinx.dataframe.impl.columns.changePath
+
+internal tailrec fun <T> ReadonlyTreeNode<T>.getAncestor(depth: Int): ReadonlyTreeNode<T> {
+    if (depth > this.depth) throw UnsupportedOperationException()
+    if (depth == this.depth) return this
+    val p = parent ?: throw UnsupportedOperationException()
+    return p.getAncestor(depth)
+}
+
+internal fun <T> TreeNode<T?>.getOrPut(path: ColumnPath) = getOrPutEmpty(path, null)
+
+internal fun <T> TreeNode<T>.getOrPutEmpty(path: ColumnPath, emptyData: T): TreeNode<T> = getOrPut(path) { emptyData }
+
+internal fun <T> TreeNode<T?>.put(path: ColumnPath, data: T): TreeNode<T?> = getOrPut(path).also { it.data = data }
+
+internal fun <T> TreeNode<T>.getOrPut(path: ColumnPath, createData: (ColumnPath) -> T): TreeNode<T> {
+    var node = this
+    path.indices.forEach {
+        node = node.getOrPut(path[it]) { createData(path.take(it + 1)) }
+    }
+    return node
+}
+
+/**
+ * Traverses all children in the tree in depth-first order and returns the top-most nodes that satisfy
+ * [yieldCondition]. This means that if a node satisfies [yieldCondition], its children are not traversed, regardless of
+ * whether they satisfy [yieldCondition] or not.
+ */
+internal fun <T> TreeNode<T>.topmostChildren(yieldCondition: (TreeNode<T>) -> Boolean): List<TreeNode<T>> =
+    allChildren(
+        enterCondition = { !yieldCondition(it) },
+        yieldCondition = yieldCondition,
+    )
+
+internal fun <T> TreeNode<T>.topmostChildrenExcluding(excludeRoot: TreeNode<*>): List<TreeNode<T>> {
+    val result = mutableListOf<TreeNode<T>>()
+
+    fun doDfs(node: TreeNode<T>, exclude: TreeNode<*>) {
+        if (exclude.children.isNotEmpty()) {
+            node.children.filter { !exclude.contains(it.name) }.forEach { result.add(it) }
+            exclude.children.forEach {
+                val srcNode = node[it.name]
+                if (srcNode != null) {
+                    doDfs(srcNode, it)
+                }
+            }
+        }
+    }
+    doDfs(this, excludeRoot)
+    return result
+}
+
+/**
+ * Mapping function for [ReadonlyTreeNodes][ReadonlyTreeNode] (like [TreeNode])
+ * which can convert the tree-structure (depth-first) to any other tree-type structure (e.g. [DataFrame]).
+ */
+@Suppress("UNCHECKED_CAST")
+internal fun <T : ReadonlyTreeNode<*>, R> T.map(operation: (node: T, children: List<R>) -> R): R {
+    val children = children.map { (it as T).map(operation) }
+    return operation(this, children)
+}
+
+internal fun <T> TreeNode<T?>.allChildrenNotNull(): List<TreeNode<T>> =
+    allChildren { it.data != null } as List<TreeNode<T>>
+
+internal fun <T> TreeNode<T?>.topmostChildrenNotNull() = topmostChildren { it.data != null } as List<TreeNode<T>>
+
+internal fun TreeNode<ColumnPosition>.allRemovedColumns() = allChildren { it.data.wasRemoved && it.data.column != null }
+
+internal fun TreeNode<ColumnPosition>.allWithColumns() = allChildren { it.data.column != null }
+
+internal fun Iterable<ColumnWithPath<*>>.flattenRecursively(): List<ColumnWithPath<*>> {
+    val result = mutableListOf<ColumnWithPath<*>>()
+
+    fun flattenRecursively(cols: Iterable<ColumnWithPath<*>>) {
+        cols.forEach {
+            result.add(it)
+            val path = it.path
+            val data = it.data
+            if (data.isColumnGroup()) {
+                flattenRecursively(
+                    data.columns().map { it.addPath(path + it.name()) },
+                )
+            }
+        }
+    }
+    flattenRecursively(this)
+    return result
+}
+
+internal fun List<ColumnWithPath<*>>.collectTree() = collectTree(null) { it }
+
+internal fun <D> List<ColumnWithPath<*>>.collectTree(emptyData: D, createData: (AnyCol) -> D): TreeNode<D> {
+    val root = TreeNode.createRoot(emptyData)
+
+    fun collectColumns(col: AnyCol, parentNode: TreeNode<D>) {
+        val newNode = parentNode.getOrPut(col.name()) { createData(col) }
+        if (col.isColumnGroup()) {
+            col.asColumnGroup().columns().forEach {
+                collectColumns(it, newNode)
+            }
+        }
+    }
+    forEach {
+        if (it.path.isEmpty()) {
+            it.data.asColumnGroup().columns().forEach {
+                collectColumns(it, root)
+            }
+        } else {
+            val node = root.getOrPutEmpty(it.path.dropLast(1), emptyData)
+            collectColumns(it.data, node)
+        }
+    }
+    return root
+}
+
+/**
+ * Shorten column paths as much as possible to keep them unique
+ */
+internal fun <C> List<ColumnWithPath<C>>.shortenPaths(): List<ColumnWithPath<C>> {
+    // try to use just column name as column path
+    val map = groupBy { it.path.takeLast(1) }.toMutableMap()
+
+    fun add(path: ColumnPath, column: ColumnWithPath<C>) {
+        val list: MutableList<ColumnWithPath<C>> =
+            (map.getOrPut(path) { mutableListOf() } as? MutableList<ColumnWithPath<C>>)
+                ?: let {
+                    val values = map.remove(path)!!
+                    map.put(path, values.toMutableList()) as MutableList<ColumnWithPath<C>>
+                }
+        list.add(column)
+    }
+
+    // resolve name collisions by using more parts of column path
+    var conflicts = map.filter { it.value.size > 1 }
+    while (conflicts.size > 0) {
+        conflicts.forEach {
+            val key = it.key
+            val keyLength = key.size
+            map.remove(key)
+            it.value.forEach {
+                val path = it.path
+                val newPath = if (path.size < keyLength) path.takeLast(keyLength + 1) else path
+                add(newPath, it)
+            }
+        }
+        conflicts = map.filter { it.value.size > 1 }
+    }
+
+    val pathRemapping = map.map { it.value.single().path to it.key }.toMap()
+
+    return map { it.changePath(pathRemapping[it.path]!!) }
+}
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/io/BytesUtils.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/io/BytesUtils.kt
new file mode 100644
index 000000000..9994ba56c
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/io/BytesUtils.kt
@@ -0,0 +1,5 @@
+package org.jetbrains.kotlinx.dataframe.impl.io
+
+import java.util.Base64
+
+internal fun ByteArray.toBase64(): String = Base64.getEncoder().encodeToString(this)
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/io/compression.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/io/compression.kt
new file mode 100644
index 000000000..8d95b811e
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/io/compression.kt
@@ -0,0 +1,11 @@
+package org.jetbrains.kotlinx.dataframe.impl.io
+
+import java.io.ByteArrayOutputStream
+import java.util.zip.GZIPOutputStream
+
+internal fun ByteArray.encodeGzip(): ByteArray {
+    val bos = ByteArrayOutputStream()
+    GZIPOutputStream(bos).use { it.write(this) }
+
+    return bos.toByteArray()
+}
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/io/image.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/io/image.kt
new file mode 100644
index 000000000..782288718
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/io/image.kt
@@ -0,0 +1,60 @@
+package org.jetbrains.kotlinx.dataframe.impl.io
+
+import java.awt.Graphics2D
+import java.awt.RenderingHints
+import java.awt.image.BufferedImage
+import java.awt.image.ImageObserver
+import java.io.ByteArrayOutputStream
+import javax.imageio.ImageIO
+import kotlin.math.max
+import kotlin.math.min
+
+internal fun BufferedImage.resizeKeepingAspectRatio(
+    maxSize: Int,
+    resultImageType: Int = BufferedImage.TYPE_INT_ARGB,
+    interpolation: Any = RenderingHints.VALUE_INTERPOLATION_NEAREST_NEIGHBOR,
+    renderingQuality: Any = RenderingHints.VALUE_RENDER_QUALITY,
+    antialiasing: Any = RenderingHints.VALUE_ANTIALIAS_ON,
+    observer: ImageObserver? = null,
+): BufferedImage {
+    val aspectRatio = width.toDouble() / height.toDouble()
+    val size = min(maxSize, max(width, height))
+
+    val (nWidth, nHeight) = if (width > height) {
+        Pair(size, (size / aspectRatio).toInt())
+    } else {
+        Pair((size * aspectRatio).toInt(), size)
+    }
+
+    return resize(nWidth, nHeight, resultImageType, interpolation, renderingQuality, antialiasing, observer)
+}
+
+internal fun BufferedImage.resize(
+    width: Int,
+    height: Int,
+    resultImageType: Int = BufferedImage.TYPE_INT_ARGB,
+    interpolation: Any = RenderingHints.VALUE_INTERPOLATION_NEAREST_NEIGHBOR,
+    renderingQuality: Any = RenderingHints.VALUE_RENDER_QUALITY,
+    antialiasing: Any = RenderingHints.VALUE_ANTIALIAS_ON,
+    observer: ImageObserver? = null,
+): BufferedImage {
+    val resized = BufferedImage(width, height, resultImageType)
+    val g: Graphics2D = resized.createGraphics()
+
+    g.setRenderingHint(RenderingHints.KEY_INTERPOLATION, interpolation)
+    g.setRenderingHint(RenderingHints.KEY_RENDERING, renderingQuality)
+    g.setRenderingHint(RenderingHints.KEY_ANTIALIASING, antialiasing)
+
+    g.drawImage(this, 0, 0, width, height, observer)
+    g.dispose()
+
+    return resized
+}
+
+internal const val DEFAULT_IMG_FORMAT = "png"
+
+internal fun BufferedImage.toByteArray(format: String = DEFAULT_IMG_FORMAT): ByteArray =
+    ByteArrayOutputStream().use { bos ->
+        ImageIO.write(this, format, bos)
+        bos.toByteArray()
+    }
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/io/readJson.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/io/readJson.kt
new file mode 100644
index 000000000..fca2bd4e7
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/io/readJson.kt
@@ -0,0 +1,700 @@
+package org.jetbrains.kotlinx.dataframe.impl.io
+
+import kotlinx.serialization.json.JsonArray
+import kotlinx.serialization.json.JsonNull
+import kotlinx.serialization.json.JsonObject
+import kotlinx.serialization.json.JsonPrimitive
+import kotlinx.serialization.json.boolean
+import kotlinx.serialization.json.booleanOrNull
+import kotlinx.serialization.json.double
+import kotlinx.serialization.json.doubleOrNull
+import kotlinx.serialization.json.float
+import kotlinx.serialization.json.floatOrNull
+import kotlinx.serialization.json.int
+import kotlinx.serialization.json.intOrNull
+import kotlinx.serialization.json.jsonArray
+import kotlinx.serialization.json.long
+import kotlinx.serialization.json.longOrNull
+import org.jetbrains.kotlinx.dataframe.AnyCol
+import org.jetbrains.kotlinx.dataframe.AnyFrame
+import org.jetbrains.kotlinx.dataframe.DataColumn
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.DataRow
+import org.jetbrains.kotlinx.dataframe.api.JsonPath
+import org.jetbrains.kotlinx.dataframe.api.KeyValueProperty
+import org.jetbrains.kotlinx.dataframe.api.cast
+import org.jetbrains.kotlinx.dataframe.api.columnOf
+import org.jetbrains.kotlinx.dataframe.api.concat
+import org.jetbrains.kotlinx.dataframe.api.dataFrameOf
+import org.jetbrains.kotlinx.dataframe.api.firstOrNull
+import org.jetbrains.kotlinx.dataframe.api.getColumn
+import org.jetbrains.kotlinx.dataframe.api.mapIndexed
+import org.jetbrains.kotlinx.dataframe.api.named
+import org.jetbrains.kotlinx.dataframe.api.schema
+import org.jetbrains.kotlinx.dataframe.api.splitInto
+import org.jetbrains.kotlinx.dataframe.api.toDataFrame
+import org.jetbrains.kotlinx.dataframe.columns.ColumnGroup
+import org.jetbrains.kotlinx.dataframe.columns.FrameColumn
+import org.jetbrains.kotlinx.dataframe.impl.ColumnNameGenerator
+import org.jetbrains.kotlinx.dataframe.impl.DataCollectorBase
+import org.jetbrains.kotlinx.dataframe.impl.asList
+import org.jetbrains.kotlinx.dataframe.impl.columns.createColumn
+import org.jetbrains.kotlinx.dataframe.impl.commonType
+import org.jetbrains.kotlinx.dataframe.impl.createDataCollector
+import org.jetbrains.kotlinx.dataframe.impl.guessValueType
+import org.jetbrains.kotlinx.dataframe.impl.schema.DataFrameSchemaImpl
+import org.jetbrains.kotlinx.dataframe.impl.schema.extractSchema
+import org.jetbrains.kotlinx.dataframe.impl.schema.intersectSchemas
+import org.jetbrains.kotlinx.dataframe.impl.splitByIndices
+import org.jetbrains.kotlinx.dataframe.io.ARRAY_COLUMN_NAME
+import org.jetbrains.kotlinx.dataframe.io.JSON.TypeClashTactic
+import org.jetbrains.kotlinx.dataframe.io.JSON.TypeClashTactic.ANY_COLUMNS
+import org.jetbrains.kotlinx.dataframe.io.JSON.TypeClashTactic.ARRAY_AND_VALUE_COLUMNS
+import org.jetbrains.kotlinx.dataframe.io.VALUE_COLUMN_NAME
+import org.jetbrains.kotlinx.dataframe.ncol
+import org.jetbrains.kotlinx.dataframe.nrow
+import org.jetbrains.kotlinx.dataframe.schema.ColumnSchema
+import org.jetbrains.kotlinx.dataframe.type
+import org.jetbrains.kotlinx.dataframe.typeClass
+import org.jetbrains.kotlinx.dataframe.values
+import kotlin.reflect.KType
+import kotlin.reflect.KTypeProjection
+import kotlin.reflect.full.createType
+import kotlin.reflect.typeOf
+
+private fun DataFrame<Any?>.unwrapUnnamedColumns() = dataFrameOf(columns().map { it.unwrapUnnamedColumn() })
+
+private fun AnyCol.unwrapUnnamedColumn() = if (this is UnnamedColumn) col else this
+
+private enum class AnyColType {
+    ANY,
+    ARRAYS,
+    OBJECTS,
+}
+
+internal interface AnyKeyValueProperty : KeyValueProperty<Any?> {
+    override val value: Any?
+}
+
+internal fun readJson(
+    parsed: Any?,
+    header: List<String>,
+    keyValuePaths: List<JsonPath> = emptyList(),
+    typeClashTactic: TypeClashTactic = ARRAY_AND_VALUE_COLUMNS,
+): DataFrame<*> {
+    val df: AnyFrame = when (typeClashTactic) {
+        ARRAY_AND_VALUE_COLUMNS -> {
+            when (parsed) {
+                is JsonArray -> fromJsonListArrayAndValueColumns(
+                    records = parsed,
+                    header = header,
+                    keyValuePaths = keyValuePaths,
+                )
+
+                else -> fromJsonListArrayAndValueColumns(
+                    records = listOf(parsed),
+                    keyValuePaths = keyValuePaths,
+                )
+            }
+        }
+
+        ANY_COLUMNS -> {
+            when (parsed) {
+                is JsonArray -> fromJsonListAnyColumns(
+                    records = parsed,
+                    header = header,
+                    keyValuePaths = keyValuePaths,
+                )
+
+                else -> fromJsonListAnyColumns(
+                    records = listOf(parsed),
+                    keyValuePaths = keyValuePaths,
+                )
+            }
+        }
+    }
+    return df.unwrapUnnamedColumns()
+}
+
+/**
+ * Json to DataFrame converter that creates [Any] columns.
+ * A.k.a. [TypeClashTactic.ANY_COLUMNS].
+ *
+ * @param records List of json elements to be converted to a [DataFrame].
+ * @param keyValuePaths List of [JsonPath]s where instead of a [ColumnGroup], a [FrameColumn]<[KeyValueProperty]>
+ *     will be created.
+ * @param header Optional list of column names. If given, [records] will be read like an object with [header] being the keys.
+ * @return [DataFrame] from the given [records].
+ */
+internal fun fromJsonListAnyColumns(
+    records: List<*>,
+    keyValuePaths: List<JsonPath> = emptyList(),
+    header: List<String> = emptyList(),
+    jsonPath: JsonPath = JsonPath(),
+): AnyFrame {
+    var hasPrimitive = false
+    var hasArray = false
+    var hasObject = false
+
+    // list element type can be JsonObject, JsonArray or primitive
+    val nameGenerator = ColumnNameGenerator()
+    records.forEach { record ->
+        when (record) {
+            is JsonObject -> {
+                hasObject = true
+                record.entries.forEach { nameGenerator.addIfAbsent(it.key) }
+            }
+
+            is JsonArray -> hasArray = true
+
+            is JsonNull, null -> Unit
+
+            is JsonPrimitive -> hasPrimitive = true
+        }
+    }
+
+    val colType = when {
+        hasArray && !hasPrimitive && !hasObject -> AnyColType.ARRAYS
+        hasObject && !hasPrimitive && !hasArray -> AnyColType.OBJECTS
+        else -> AnyColType.ANY
+    }
+    val justPrimitives = hasPrimitive && !hasArray && !hasObject
+    val isKeyValue = keyValuePaths.any { jsonPath.matches(it) }
+
+    if (isKeyValue && colType != AnyColType.OBJECTS) {
+        error("Key value path $jsonPath does not match objects.")
+    }
+
+    @Suppress("KotlinConstantConditions")
+    val columns: List<AnyCol> = when {
+        // Create one column of type Any? (or guessed primitive type) from all the records
+        colType == AnyColType.ANY -> {
+            val collector: DataCollectorBase<Any?> =
+                if (justPrimitives) {
+                    createDataCollector(records.size) // guess the type
+                } else {
+                    createDataCollector(records.size, typeOf<Any?>()) // use Any?
+                }
+
+            val nanIndices = mutableListOf<Int>()
+            records.forEachIndexed { i, v ->
+                when (v) {
+                    is JsonObject -> {
+                        val parsed =
+                            fromJsonListAnyColumns(
+                                records = listOf(v),
+                                keyValuePaths = keyValuePaths,
+                                jsonPath = jsonPath.replaceLastWildcardWithIndex(i),
+                            )
+                        collector.add(
+                            if (parsed.isSingleUnnamedColumn()) {
+                                (parsed.getColumn(0) as UnnamedColumn).col.values.first()
+                            } else {
+                                parsed.firstOrNull() ?: DataRow.empty
+                            },
+                        )
+                    }
+
+                    is JsonArray -> {
+                        val parsed = fromJsonListAnyColumns(
+                            records = v,
+                            keyValuePaths = keyValuePaths,
+                            jsonPath = jsonPath.replaceLastWildcardWithIndex(i).appendArrayWithWildcard(),
+                        )
+                        collector.add(
+                            if (parsed.isSingleUnnamedColumn()) {
+                                (parsed.getColumn(0) as UnnamedColumn).col.values.asList()
+                            } else {
+                                parsed.unwrapUnnamedColumns()
+                            },
+                        )
+                    }
+
+                    is JsonNull -> collector.add(null)
+
+                    is JsonPrimitive -> {
+                        when {
+                            v.content == "NaN" -> {
+                                nanIndices.add(i)
+                                collector.add(null)
+                            }
+
+                            v.isString -> collector.add(v.content)
+
+                            v.booleanOrNull != null -> collector.add(v.boolean)
+
+                            v.intOrNull != null -> collector.add(v.int)
+
+                            v.longOrNull != null -> collector.add(v.long)
+
+                            v.doubleOrNull != null -> collector.add(v.double)
+
+                            v.floatOrNull != null -> collector.add(v.float)
+
+                            else -> error("Malformed JSON element ${v::class}: $v")
+                        }
+                    }
+
+                    else -> collector.add(v)
+                }
+            }
+            val column = collector.toColumn(VALUE_COLUMN_NAME)
+            val res = if (nanIndices.isNotEmpty()) {
+                fun <C> DataColumn<C>.updateNaNs(nanValue: C): DataColumn<C> {
+                    var j = 0
+                    var nextNanIndex = nanIndices[j]
+                    return mapIndexed(column.type) { i, v ->
+                        if (i == nextNanIndex) {
+                            j++
+                            nextNanIndex = if (j < nanIndices.size) nanIndices[j] else -1
+                            nanValue
+                        } else {
+                            v
+                        }
+                    }
+                }
+                when (column.typeClass) {
+                    Double::class -> column.cast<Double?>().updateNaNs(Double.NaN)
+                    Float::class -> column.cast<Float?>().updateNaNs(Float.NaN)
+                    String::class -> column.cast<String?>().updateNaNs("NaN")
+                    else -> column
+                }
+            } else {
+                column
+            }
+            listOf(UnnamedColumn(res))
+        }
+
+        // Create one column of type FrameColumn, or List<> from all the records if they are all arrays
+        colType == AnyColType.ARRAYS -> {
+            val values = mutableListOf<Any?>()
+            val startIndices = ArrayList<Int>()
+            records.forEach {
+                startIndices.add(values.size)
+                when (it) {
+                    is JsonArray -> values.addAll(it)
+                    is JsonNull, null -> Unit
+                    else -> error("Expected JsonArray, got $it")
+                }
+            }
+            val parsed = fromJsonListAnyColumns(
+                records = values,
+                keyValuePaths = keyValuePaths,
+                jsonPath = jsonPath.appendArrayWithWildcard(),
+            )
+
+            val res = when {
+                parsed.isSingleUnnamedColumn() -> {
+                    val col = (parsed.getColumn(0) as UnnamedColumn).col
+                    val elementType = col.type
+                    val columnValues = col.values
+                        .asList()
+                        .splitByIndices(startIndices.asSequence())
+                        .toList()
+                    DataColumn.createValueColumn(
+                        name = ARRAY_COLUMN_NAME,
+                        values = columnValues,
+                        type = List::class.createType(listOf(KTypeProjection.invariant(elementType))),
+                    )
+                }
+
+                else -> DataColumn.createFrameColumn(
+                    name = ARRAY_COLUMN_NAME, // will be erased
+                    df = parsed.unwrapUnnamedColumns(),
+                    startIndices = startIndices,
+                )
+            }
+            listOf(UnnamedColumn(res))
+        }
+
+        // Create one column of type FrameColumn<KeyValueProperty>
+        colType == AnyColType.OBJECTS && isKeyValue -> {
+            // collect the value types to make sure Value columns with lists and other values aren't all turned into lists
+            val valueTypes = mutableSetOf<KType>()
+            val dataFrames = records.map { record ->
+                when (record) {
+                    is JsonObject -> {
+                        val map = record.mapValues { (key, value) ->
+                            val parsed = fromJsonListAnyColumns(
+                                records = listOf(value),
+                                keyValuePaths = keyValuePaths,
+                                jsonPath = jsonPath.append(key),
+                            )
+                            if (parsed.isSingleUnnamedColumn()) {
+                                (parsed.getColumn(0) as UnnamedColumn).col.values.first()
+                            } else {
+                                parsed.unwrapUnnamedColumns().firstOrNull()
+                            }
+                        }
+                        val valueType = map.values.map {
+                            guessValueType(sequenceOf(it))
+                        }.commonType()
+
+                        valueTypes += valueType
+
+                        dataFrameOf(
+                            columnOf(*map.keys.toTypedArray()).named(KeyValueProperty<*>::key.name),
+                            createColumn(values = map.values, suggestedType = valueType, guessType = false)
+                                .named(KeyValueProperty<*>::value.name),
+                        )
+                    }
+
+                    is JsonNull, null -> DataFrame.emptyOf<AnyKeyValueProperty>()
+
+                    else -> error("Expected JsonObject, got $record")
+                }
+            }
+
+            val valueColumns = dataFrames.map { it[KeyValueProperty<*>::value.name] }
+            val valueColumnSchema = when {
+                // in these cases we can safely combine the columns to get a single column schema
+                valueColumns.all { it is ColumnGroup<*> } || valueColumns.all { it is FrameColumn<*> } ->
+                    valueColumns.concat().extractSchema()
+
+                // to avoid listification, we create the value columns schema ourselves (https://github.com/Kotlin/dataframe/issues/184)
+                else -> ColumnSchema.Value(valueTypes.commonType())
+            }
+
+            listOf(
+                UnnamedColumn(
+                    DataColumn.createFrameColumn(
+                        name = VALUE_COLUMN_NAME, // will be erased unless at top-level
+                        groups = dataFrames,
+                        schema = lazy {
+                            DataFrameSchemaImpl(
+                                columns = mapOf(
+                                    KeyValueProperty<*>::key.name to ColumnSchema.Value(typeOf<String>()),
+                                    KeyValueProperty<*>::value.name to valueColumnSchema,
+                                ),
+                            )
+                        },
+                    ),
+                ),
+            )
+        }
+
+        // Create multiple columns from all the records if they are all objects, merging the objects in essence
+        colType == AnyColType.OBJECTS && !isKeyValue -> {
+            nameGenerator.names.map { colName ->
+                val values = ArrayList<Any?>(records.size)
+
+                records.forEach {
+                    when (it) {
+                        is JsonObject -> values.add(it[colName])
+                        is JsonNull, null -> values.add(null)
+                        else -> error("Expected JsonObject, got $it")
+                    }
+                }
+
+                val parsed = fromJsonListAnyColumns(
+                    records = values,
+                    keyValuePaths = keyValuePaths,
+                    jsonPath = jsonPath.append(colName),
+                )
+                when {
+                    parsed.ncol == 0 ->
+                        DataColumn.createValueColumn(
+                            name = colName,
+                            values = arrayOfNulls<Any?>(values.size).toList(),
+                            type = typeOf<Any?>(),
+                        )
+
+                    parsed.isSingleUnnamedColumn() ->
+                        (parsed.getColumn(0) as UnnamedColumn).col.rename(colName)
+
+                    else ->
+                        DataColumn.createColumnGroup(colName, parsed.unwrapUnnamedColumns()) as AnyCol
+                }
+            }
+        }
+
+        else -> error("")
+    }
+
+    return when {
+        columns.isEmpty() -> DataFrame.empty(records.size)
+
+        columns.size == 1 && hasArray && header.isNotEmpty() && columns[0].typeClass == List::class ->
+            columns[0]
+                .cast<List<*>>()
+                .splitInto(*header.toTypedArray())
+
+        else -> columns.toDataFrame()
+    }
+}
+
+private fun AnyFrame.isSingleUnnamedColumn() = ncol == 1 && getColumn(0) is UnnamedColumn
+
+/**
+ * Json to DataFrame converter that creates allows creates `value` and `array` accessors
+ * instead of [Any] columns.
+ * A.k.a. [TypeClashTactic.ARRAY_AND_VALUE_COLUMNS].
+ *
+ * @param records List of json elements to be converted to a [DataFrame].
+ * @param keyValuePaths List of [JsonPath]s where instead of a [ColumnGroup], a [FrameColumn]<[KeyValueProperty]>
+ *     will be created.
+ * @param header Optional list of column names. If given, [records] will be read like an object with [header] being the keys.
+ * @return [DataFrame] from the given [records].
+ */
+internal fun fromJsonListArrayAndValueColumns(
+    records: List<*>,
+    keyValuePaths: List<JsonPath> = emptyList(),
+    header: List<String> = emptyList(),
+    jsonPath: JsonPath = JsonPath(),
+): AnyFrame {
+    var hasPrimitive = false
+    var hasArray = false
+    val isKeyValue = keyValuePaths.any { jsonPath.matches(it) }
+
+    // list element type can be JsonObject, JsonArray or primitive
+    // So first, we gather all properties of objects to merge including "array" and "value" if needed
+    // so the resulting type of a property with instances 123, ["abc"], and { "a": 1, "b": 2 } will be
+    // { array: List<String>, value: Int?, a: Int?, b: Int? }
+    // and instances will look like
+    // { "array": [], "value": 123, "a": null, "b": null }
+
+    val nameGenerator = ColumnNameGenerator()
+    records.forEach { record ->
+        when (record) {
+            is JsonObject -> record.entries.forEach {
+                nameGenerator.addIfAbsent(it.key)
+            }
+
+            is JsonArray -> hasArray = true
+
+            is JsonNull, null -> Unit
+
+            is JsonPrimitive -> hasPrimitive = true
+        }
+    }
+    if (records.all { it == null || it is JsonNull }) hasPrimitive = true
+
+    // Add a value column to the collected names if needed
+    val valueColumn = if (hasPrimitive || records.isEmpty()) {
+        nameGenerator.addUnique(VALUE_COLUMN_NAME)
+    } else {
+        null
+    }
+
+    // Add an array column to the collected names if needed
+    val arrayColumn = if (hasArray) {
+        nameGenerator.addUnique(ARRAY_COLUMN_NAME)
+    } else {
+        null
+    }
+
+    // only properties that consist of just objects (or are empty) can be merged to key/value FrameColumns
+    if (isKeyValue && (hasPrimitive || hasArray)) {
+        error("Key value path $jsonPath does not match objects.")
+    }
+
+    // Create columns from the collected names
+    val columns: List<AnyCol> = when {
+        // instead of using the names, generate a single key/value frame column
+        isKeyValue -> {
+            val dataFrames = records.map { record ->
+                when (record) {
+                    is JsonObject -> {
+                        val map = record.mapValues { (key, value) ->
+                            val parsed = fromJsonListArrayAndValueColumns(
+                                records = listOf(value),
+                                keyValuePaths = keyValuePaths,
+                                jsonPath = jsonPath.append(key),
+                            )
+                            if (parsed.isSingleUnnamedColumn()) {
+                                (parsed.getColumn(0) as UnnamedColumn).col.values.first()
+                            } else {
+                                parsed.unwrapUnnamedColumns().firstOrNull()
+                            }
+                        }
+                        val valueType =
+                            map.values
+                                .map { guessValueType(sequenceOf(it)) }
+                                .commonType()
+
+                        dataFrameOf(
+                            columnOf(*map.keys.toTypedArray()).named(KeyValueProperty<*>::key.name),
+                            createColumn(
+                                values = map.values,
+                                suggestedType = valueType,
+                                guessType = false,
+                            ).named(KeyValueProperty<*>::value.name),
+                        )
+                    }
+
+                    is JsonNull, null -> DataFrame.emptyOf<AnyKeyValueProperty>()
+
+                    else -> error("Expected JsonObject, got $record")
+                }
+            }
+
+            listOf(
+                UnnamedColumn(
+                    DataColumn.createFrameColumn(
+                        name = VALUE_COLUMN_NAME, // will be erased unless at top-level
+                        groups = dataFrames,
+                        schema = lazy {
+                            dataFrames.mapNotNull { it.takeIf { it.nrow > 0 }?.schema() }.intersectSchemas()
+                        },
+                    ),
+                ),
+            )
+        }
+
+        // generate columns using the collected names
+        else ->
+            nameGenerator.names.map { colName ->
+                when {
+                    // Collect primitive values from records into the `value` column if needed
+                    colName == valueColumn && (hasPrimitive || records.isEmpty()) -> {
+                        val collector = createDataCollector(records.size)
+                        val nanIndices = mutableListOf<Int>()
+                        records.forEachIndexed { i, v ->
+                            when (v) {
+                                is JsonObject -> collector.add(null)
+
+                                is JsonArray -> collector.add(null)
+
+                                is JsonNull -> collector.add(null)
+
+                                is JsonPrimitive -> {
+                                    when {
+                                        v.content == "NaN" -> {
+                                            nanIndices.add(i)
+                                            collector.add(null)
+                                        }
+
+                                        v.isString -> collector.add(v.content)
+
+                                        v.booleanOrNull != null -> collector.add(v.boolean)
+
+                                        v.intOrNull != null -> collector.add(v.int)
+
+                                        v.longOrNull != null -> collector.add(v.long)
+
+                                        v.doubleOrNull != null -> collector.add(v.double)
+
+                                        v.floatOrNull != null -> collector.add(v.float)
+
+                                        else -> error("Malformed JSON element ${v::class}: $v")
+                                    }
+                                }
+
+                                else -> collector.add(v)
+                            }
+                        }
+                        val column = collector.toColumn(colName)
+                        val res = if (nanIndices.isNotEmpty()) {
+                            fun <C> DataColumn<C>.updateNaNs(nanValue: C): DataColumn<C> {
+                                var j = 0
+                                var nextNanIndex = nanIndices[j]
+                                return mapIndexed(column.type) { i, v ->
+                                    if (i == nextNanIndex) {
+                                        j++
+                                        nextNanIndex = if (j < nanIndices.size) nanIndices[j] else -1
+                                        nanValue
+                                    } else {
+                                        v
+                                    }
+                                }
+                            }
+                            when (column.typeClass) {
+                                Double::class -> column.cast<Double?>().updateNaNs(Double.NaN)
+                                Float::class -> column.cast<Float?>().updateNaNs(Float.NaN)
+                                String::class -> column.cast<String?>().updateNaNs("NaN")
+                                else -> column
+                            }
+                        } else {
+                            column
+                        }
+                        UnnamedColumn(res)
+                    }
+
+                    // Collect arrays from records into the `array` column if needed
+                    colName == arrayColumn && hasArray -> {
+                        val values = mutableListOf<Any?>()
+                        val startIndices = ArrayList<Int>()
+                        records.forEach {
+                            startIndices.add(values.size)
+                            if (it is JsonArray) values.addAll(it.jsonArray)
+                        }
+                        val parsed = fromJsonListArrayAndValueColumns(
+                            records = values,
+                            keyValuePaths = keyValuePaths,
+                            jsonPath = jsonPath.appendArrayWithWildcard(),
+                        )
+
+                        val res = when {
+                            parsed.isSingleUnnamedColumn() -> {
+                                val col = (parsed.getColumn(0) as UnnamedColumn).col
+                                val elementType = col.type
+                                val columnValues =
+                                    col.values
+                                        .asList()
+                                        .splitByIndices(startIndices.asSequence())
+                                        .toList()
+                                DataColumn.createValueColumn(
+                                    name = colName,
+                                    values = columnValues,
+                                    type = List::class.createType(listOf(KTypeProjection.invariant(elementType))),
+                                )
+                            }
+
+                            else -> DataColumn.createFrameColumn(colName, parsed.unwrapUnnamedColumns(), startIndices)
+                        }
+                        UnnamedColumn(res)
+                    }
+
+                    // Collect the current column name as property from the objects in records
+                    else -> {
+                        val values = ArrayList<Any?>(records.size)
+                        records.forEach {
+                            when (it) {
+                                is JsonObject -> values.add(it[colName])
+                                else -> values.add(null)
+                            }
+                        }
+
+                        val parsed = fromJsonListArrayAndValueColumns(
+                            records = values,
+                            keyValuePaths = keyValuePaths,
+                            jsonPath = jsonPath.append(colName),
+                        )
+                        when {
+                            parsed.ncol == 0 ->
+                                DataColumn.createValueColumn(
+                                    name = colName,
+                                    values = arrayOfNulls<Any?>(values.size).toList(),
+                                    type = typeOf<Any?>(),
+                                )
+
+                            parsed.isSingleUnnamedColumn() ->
+                                (parsed.getColumn(0) as UnnamedColumn).col.rename(colName)
+
+                            else ->
+                                DataColumn.createColumnGroup(colName, parsed.unwrapUnnamedColumns()) as AnyCol
+                        }
+                    }
+                }
+            }
+    }
+
+    return when {
+        columns.isEmpty() ->
+            DataFrame.empty(records.size)
+
+        columns.size == 1 && hasArray && header.isNotEmpty() && columns[0].typeClass == List::class ->
+            columns[0]
+                .cast<List<*>>()
+                .splitInto(*header.toTypedArray())
+
+        else ->
+            columns.toDataFrame()
+    }
+}
+
+// we need it to check if AnyFrame created by recursive call has single unnamed column,
+// unnamed column means this column is not created from field of a record [{"value": 1}, {"value": 2}],
+// but filtered values [1, { ... }, []] -> [1, null, null]
+// or arrays: [1, { ...}, []] -> [null, null, []]
+private class UnnamedColumn(val col: DataColumn<Any?>) : DataColumn<Any?> by col
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/io/writeJson.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/io/writeJson.kt
new file mode 100644
index 000000000..1b1c61c32
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/io/writeJson.kt
@@ -0,0 +1,403 @@
+@file:OptIn(ExperimentalSerializationApi::class)
+
+package org.jetbrains.kotlinx.dataframe.impl.io
+
+import kotlinx.serialization.ExperimentalSerializationApi
+import kotlinx.serialization.json.Json
+import kotlinx.serialization.json.JsonArray
+import kotlinx.serialization.json.JsonElement
+import kotlinx.serialization.json.JsonObject
+import kotlinx.serialization.json.JsonPrimitive
+import kotlinx.serialization.json.buildJsonArray
+import kotlinx.serialization.json.buildJsonObject
+import kotlinx.serialization.json.encodeToJsonElement
+import kotlinx.serialization.json.putJsonArray
+import kotlinx.serialization.json.putJsonObject
+import org.jetbrains.kotlinx.dataframe.AnyCol
+import org.jetbrains.kotlinx.dataframe.AnyFrame
+import org.jetbrains.kotlinx.dataframe.ColumnsContainer
+import org.jetbrains.kotlinx.dataframe.DataColumn
+import org.jetbrains.kotlinx.dataframe.api.indices
+import org.jetbrains.kotlinx.dataframe.api.isList
+import org.jetbrains.kotlinx.dataframe.api.rows
+import org.jetbrains.kotlinx.dataframe.api.schema
+import org.jetbrains.kotlinx.dataframe.api.take
+import org.jetbrains.kotlinx.dataframe.columns.CellKind
+import org.jetbrains.kotlinx.dataframe.columns.ColumnGroup
+import org.jetbrains.kotlinx.dataframe.columns.ColumnKind
+import org.jetbrains.kotlinx.dataframe.columns.FrameColumn
+import org.jetbrains.kotlinx.dataframe.impl.io.SerializationKeys.COLUMNS
+import org.jetbrains.kotlinx.dataframe.impl.io.SerializationKeys.DATA
+import org.jetbrains.kotlinx.dataframe.impl.io.SerializationKeys.KIND
+import org.jetbrains.kotlinx.dataframe.impl.io.SerializationKeys.KOTLIN_DATAFRAME
+import org.jetbrains.kotlinx.dataframe.impl.io.SerializationKeys.METADATA
+import org.jetbrains.kotlinx.dataframe.impl.io.SerializationKeys.NCOL
+import org.jetbrains.kotlinx.dataframe.impl.io.SerializationKeys.NROW
+import org.jetbrains.kotlinx.dataframe.impl.io.SerializationKeys.TYPE
+import org.jetbrains.kotlinx.dataframe.impl.io.SerializationKeys.TYPES
+import org.jetbrains.kotlinx.dataframe.impl.io.SerializationKeys.VERSION
+import org.jetbrains.kotlinx.dataframe.io.ARRAY_COLUMN_NAME
+import org.jetbrains.kotlinx.dataframe.io.Base64ImageEncodingOptions
+import org.jetbrains.kotlinx.dataframe.io.CustomEncoder
+import org.jetbrains.kotlinx.dataframe.io.VALUE_COLUMN_NAME
+import org.jetbrains.kotlinx.dataframe.jupyter.KotlinNotebookPluginUtils
+import org.jetbrains.kotlinx.dataframe.jupyter.KotlinNotebookPluginUtils.isDataframeConvertable
+import org.jetbrains.kotlinx.dataframe.name
+import org.jetbrains.kotlinx.dataframe.ncol
+import org.jetbrains.kotlinx.dataframe.nrow
+import org.jetbrains.kotlinx.dataframe.schema.ColumnSchema
+import org.jetbrains.kotlinx.dataframe.typeClass
+import java.awt.image.BufferedImage
+import java.io.IOException
+
+// See docs/serialization_format.md for a description of
+// serialization versions and format.
+internal const val SERIALIZATION_VERSION = "2.1.1"
+
+internal object SerializationKeys {
+    const val DATA = "data"
+    const val METADATA = "metadata"
+    const val KIND = "kind"
+    const val NCOL = "ncol"
+    const val NROW = "nrow"
+    const val VERSION = "\$version"
+    const val COLUMNS = "columns"
+    const val KOTLIN_DATAFRAME = "kotlin_dataframe"
+    const val TYPE = "type"
+    const val TYPES = "types"
+}
+
+private val valueTypes =
+    setOf(Boolean::class, Double::class, Int::class, Float::class, Long::class, Short::class, Byte::class)
+
+@OptIn(ExperimentalSerializationApi::class)
+private fun convert(value: Any?): JsonElement =
+    when (value) {
+        is JsonElement -> value
+        is Number -> JsonPrimitive(value)
+        is String -> JsonPrimitive(value)
+        is Char -> JsonPrimitive(value.toString())
+        is Boolean -> JsonPrimitive(value)
+        null -> JsonPrimitive(null)
+        else -> JsonPrimitive(value.toString())
+    }
+
+internal fun encodeRow(frame: ColumnsContainer<*>, index: Int): JsonObject {
+    val values: Map<String, JsonElement> = frame.columns().associate { col ->
+        col.name to when {
+            col is ColumnGroup<*> -> encodeRow(col, index)
+
+            col is FrameColumn<*> -> encodeFrame(col[index])
+
+            col.isList() -> {
+                col[index]?.let {
+                    JsonArray((it as List<*>).map { value -> convert(value) })
+                } ?: JsonPrimitive(null)
+            }
+
+            col.typeClass in valueTypes -> {
+                val v = col[index]
+                convert(v)
+            }
+
+            else -> JsonPrimitive(col[index]?.toString())
+        }
+    }
+
+    if (values.isEmpty()) return buildJsonObject { }
+    return JsonObject(values)
+}
+
+internal fun encodeRowWithMetadata(
+    frame: ColumnsContainer<*>,
+    index: Int,
+    rowLimit: Int? = null,
+    customEncoders: List<CustomEncoder> = emptyList(),
+): JsonElement? {
+    val values: List<Pair<String, JsonElement>> = frame.columns().map { col ->
+        when (col) {
+            is ColumnGroup<*> -> {
+                val schema = col.schema()
+                buildJsonObject {
+                    put(DATA, encodeRowWithMetadata(col, index, rowLimit, customEncoders) ?: JsonPrimitive(null))
+                    putJsonObject(METADATA) {
+                        put(KIND, JsonPrimitive(ColumnKind.Group.toString()))
+                        put(COLUMNS, Json.encodeToJsonElement(schema.columns.keys))
+                        putJsonArray(TYPES) {
+                            addAll(
+                                schema.columns.values.map { columnSchema ->
+                                    createJsonTypeDescriptor(columnSchema)
+                                },
+                            )
+                        }
+                    }
+                }
+            }
+
+            is FrameColumn<*> -> {
+                val data = if (rowLimit == null) {
+                    encodeFrameWithMetadata(col[index], null, customEncoders)
+                } else {
+                    encodeFrameWithMetadata(col[index].take(rowLimit), rowLimit, customEncoders)
+                }
+                val schema = col.schema.value
+                buildJsonObject {
+                    put(DATA, data)
+                    putJsonObject(METADATA) {
+                        put(KIND, JsonPrimitive(ColumnKind.Frame.toString()))
+                        put(COLUMNS, Json.encodeToJsonElement(schema.columns.keys))
+                        putJsonArray(TYPES) {
+                            addAll(
+                                schema.columns.values.map { columnSchema ->
+                                    createJsonTypeDescriptor(columnSchema)
+                                },
+                            )
+                        }
+                        put(NCOL, JsonPrimitive(col[index].ncol))
+                        put(NROW, JsonPrimitive(col[index].nrow))
+                    }
+                }
+            }
+
+            else -> encodeValue(col, index, customEncoders)
+        }.let { col.name to it }
+    }
+    if (values.isEmpty()) return null
+    return JsonObject(values.toMap())
+}
+
+internal fun encodeValue(col: AnyCol, index: Int, customEncoders: List<CustomEncoder> = emptyList()): JsonElement {
+    val matchingEncoder = customEncoders.firstOrNull { it.canEncode(col[index]) }
+
+    return when {
+        matchingEncoder != null -> matchingEncoder.encode(col[index])
+
+        col.isList() -> col[index]?.let { list ->
+            val values = (list as List<*>).map { convert(it) }
+            JsonArray(values)
+        } ?: JsonArray(emptyList())
+
+        col.typeClass in valueTypes -> convert(col[index])
+
+        else -> JsonPrimitive(col[index]?.toString())
+    }
+}
+
+internal class DataframeConvertableEncoder(
+    private val encoders: List<CustomEncoder>,
+    private val rowLimit: Int? = null,
+) : CustomEncoder {
+    override fun canEncode(input: Any?): Boolean = isDataframeConvertable(input)
+
+    override fun encode(input: Any?): JsonElement =
+        input?.let {
+            val data = encodeFrameWithMetadata(
+                KotlinNotebookPluginUtils.convertToDataFrame(input),
+                rowLimit,
+                encoders,
+            )
+            buildJsonObject {
+                put(DATA, data)
+                putJsonObject(METADATA) {
+                    put(KIND, JsonPrimitive(CellKind.DataFrameConvertable.toString()))
+                }
+            }
+        } ?: JsonPrimitive(null)
+}
+
+internal class BufferedImageEncoder(private val options: Base64ImageEncodingOptions) : CustomEncoder {
+    override fun canEncode(input: Any?): Boolean = input is BufferedImage
+
+    override fun encode(input: Any?): JsonElement =
+        JsonPrimitive(
+            input?.let { image -> encodeBufferedImageAsBase64(image as BufferedImage, options) } ?: "",
+        )
+
+    private fun encodeBufferedImageAsBase64(
+        image: BufferedImage,
+        imageEncodingOptions: Base64ImageEncodingOptions = Base64ImageEncodingOptions(),
+    ): String =
+        try {
+            val preparedImage = if (imageEncodingOptions.isLimitSizeOn) {
+                image.resizeKeepingAspectRatio(imageEncodingOptions.imageSizeLimit)
+            } else {
+                image
+            }
+
+            val bytes = if (imageEncodingOptions.isGzipOn) {
+                preparedImage.toByteArray().encodeGzip()
+            } else {
+                preparedImage.toByteArray()
+            }
+
+            bytes.toBase64()
+        } catch (_: IOException) {
+            ""
+        }
+}
+
+private fun createJsonTypeDescriptor(columnSchema: ColumnSchema): JsonObject =
+    JsonObject(
+        mutableMapOf(KIND to JsonPrimitive(columnSchema.kind.toString())).also {
+            if (columnSchema.kind == ColumnKind.Value) {
+                it[TYPE] = JsonPrimitive(columnSchema.type.toString())
+            }
+        },
+    )
+
+internal fun encodeFrameWithMetadata(
+    frame: AnyFrame,
+    rowLimit: Int? = null,
+    customEncoders: List<CustomEncoder> = emptyList(),
+): JsonArray {
+    val valueColumn = frame.extractValueColumn()
+    val arrayColumn = frame.extractArrayColumn()
+
+    val arraysAreFrames = arrayColumn?.kind() == ColumnKind.Frame
+
+    val data = frame.indices().map { rowIndex ->
+        valueColumn?.get(rowIndex)
+            ?: arrayColumn?.get(rowIndex)?.let {
+                if (arraysAreFrames) {
+                    encodeFrameWithMetadata(
+                        it as AnyFrame,
+                        rowLimit,
+                        customEncoders,
+                    )
+                } else {
+                    null
+                }
+            }
+            ?: encodeRowWithMetadata(frame, rowIndex, rowLimit, customEncoders)
+    }
+
+    return buildJsonArray { addAll(data.map { convert(it) }) }
+}
+
+internal fun AnyFrame.extractValueColumn(): DataColumn<*>? {
+    val allColumns = columns()
+
+    return allColumns.filter { it.name.startsWith(VALUE_COLUMN_NAME) }
+        .takeIf { isPossibleToFindUnnamedColumns }
+        ?.maxByOrNull { it.name }
+        ?.let { valueCol ->
+            // check that value in this column is not null only when other values are null
+            if (valueCol.kind() != ColumnKind.Value) {
+                null
+            } else {
+                // check that value in this column is not null only when other values are null
+                val isValidValueColumn = rows().all { row ->
+                    if (valueCol[row] != null) {
+                        allColumns.all { col ->
+                            if (col.name != valueCol.name) {
+                                col[row] == null
+                            } else {
+                                true
+                            }
+                        }
+                    } else {
+                        true
+                    }
+                }
+                if (isValidValueColumn) {
+                    valueCol
+                } else {
+                    null
+                }
+            }
+        }
+}
+
+// If there is only 1 column, then `isValidValueColumn` always true.
+// But at the same time, we shouldn't treat dataFrameOf("value")(1,2,3) like an unnamed column
+// because it was created by the user.
+internal val AnyFrame.isPossibleToFindUnnamedColumns: Boolean
+    get() = columns().size != 1
+
+internal fun AnyFrame.extractArrayColumn(): DataColumn<*>? {
+    val allColumns = columns()
+
+    return columns().filter { it.name.startsWith(ARRAY_COLUMN_NAME) }
+        .takeIf { isPossibleToFindUnnamedColumns }
+        ?.maxByOrNull { it.name }
+        ?.let { arrayCol ->
+            if (arrayCol.kind() == ColumnKind.Group) {
+                null
+            } else {
+                // check that value in this column is not null only when other values are null
+                val isValidArrayColumn = rows().all { row ->
+                    if (arrayCol[row] != null) {
+                        allColumns.all { col ->
+                            if (col.name != arrayCol.name) {
+                                col[row] == null
+                            } else {
+                                true
+                            }
+                        }
+                    } else {
+                        true
+                    }
+                }
+                if (isValidArrayColumn) {
+                    arrayCol
+                } else {
+                    null
+                }
+            }
+        }
+}
+
+internal fun encodeFrame(frame: AnyFrame): JsonArray {
+    val valueColumn = frame.extractValueColumn()
+    val arrayColumn = frame.extractArrayColumn()
+
+    val arraysAreFrames = arrayColumn?.kind() == ColumnKind.Frame
+
+    val data = frame.indices().map { rowIndex ->
+        when {
+            valueColumn != null -> valueColumn[rowIndex]
+
+            arrayColumn != null -> arrayColumn[rowIndex]?.let {
+                if (arraysAreFrames) {
+                    encodeFrame(it as AnyFrame)
+                } else {
+                    null
+                }
+            }
+
+            else -> encodeRow(frame, rowIndex)
+        }
+    }
+
+    return buildJsonArray { addAll(data.map { convert(it) }) }
+}
+
+internal fun encodeDataFrameWithMetadata(
+    frame: AnyFrame,
+    rowLimit: Int,
+    nestedRowLimit: Int? = null,
+    customEncoders: List<CustomEncoder> = emptyList(),
+): JsonObject =
+    buildJsonObject {
+        put(VERSION, JsonPrimitive(SERIALIZATION_VERSION))
+        putJsonObject(METADATA) {
+            putJsonArray(COLUMNS) { addAll(frame.columnNames().map { JsonPrimitive(it) }) }
+            putJsonArray(TYPES) {
+                addAll(
+                    frame.schema().columns.values.map { colSchema ->
+                        createJsonTypeDescriptor(colSchema)
+                    },
+                )
+            }
+            put(NROW, JsonPrimitive(frame.rowsCount()))
+            put(NCOL, JsonPrimitive(frame.columnsCount()))
+        }
+        put(
+            KOTLIN_DATAFRAME,
+            encodeFrameWithMetadata(
+                frame = frame.take(rowLimit),
+                rowLimit = nestedRowLimit,
+                customEncoders = customEncoders,
+            ),
+        )
+    }
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/schema/DataFrameSchemaImpl.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/schema/DataFrameSchemaImpl.kt
new file mode 100644
index 000000000..f67d27c2d
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/schema/DataFrameSchemaImpl.kt
@@ -0,0 +1,75 @@
+package org.jetbrains.kotlinx.dataframe.impl.schema
+
+import org.jetbrains.kotlinx.dataframe.impl.renderType
+import org.jetbrains.kotlinx.dataframe.schema.ColumnSchema
+import org.jetbrains.kotlinx.dataframe.schema.CompareResult
+import org.jetbrains.kotlinx.dataframe.schema.DataFrameSchema
+
+public class DataFrameSchemaImpl(override val columns: Map<String, ColumnSchema>) : DataFrameSchema {
+
+    override fun compare(other: DataFrameSchema): CompareResult {
+        require(other is DataFrameSchemaImpl)
+        if (this === other) return CompareResult.Equals
+        var result = CompareResult.Equals
+        columns.forEach {
+            val otherColumn = other.columns[it.key]
+            if (otherColumn == null) {
+                result = result.combine(CompareResult.IsDerived)
+            } else {
+                result = result.combine(it.value.compare(otherColumn))
+            }
+            if (result == CompareResult.None) return CompareResult.None
+        }
+        other.columns.forEach {
+            val thisField = columns[it.key]
+            if (thisField == null) {
+                result = result.combine(CompareResult.IsSuper)
+                if (result == CompareResult.None) return CompareResult.None
+            }
+        }
+        return result
+    }
+
+    override fun equals(other: Any?): Boolean = other is DataFrameSchema && compare(other).isEqual()
+
+    override fun toString(): String = render()
+
+    override fun hashCode(): Int = columns.hashCode()
+}
+
+internal fun DataFrameSchemaImpl.render(): String {
+    val sb = StringBuilder()
+    val indentSequence = "    "
+    columns.render(0, sb, indentSequence)
+    return sb.toString()
+}
+
+internal fun Map<String, ColumnSchema>.render(indent: Int, sb: StringBuilder, indentSequence: String): String {
+    entries.forEachIndexed { i, (name, columnSchema) ->
+        sb.append(indentSequence.repeat(indent))
+        sb.append("$name:")
+        when (columnSchema) {
+            is ColumnSchema.Group -> {
+                sb.appendLine()
+                columnSchema.schema.columns.render(indent + 1, sb, indentSequence)
+                sb.appendLine()
+            }
+
+            is ColumnSchema.Frame -> {
+                sb.appendLine(" *")
+                columnSchema.schema.columns.render(indent + 1, sb, indentSequence)
+                sb.appendLine()
+            }
+
+            is ColumnSchema.Value -> {
+                sb.append(" ${renderType(columnSchema.type)}")
+                if (i != size - 1) {
+                    sb.appendLine()
+                }
+            }
+
+            else -> throw NotImplementedError(columnSchema::class.toString())
+        }
+    }
+    return sb.toString()
+}
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/schema/Utils.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/schema/Utils.kt
new file mode 100644
index 000000000..48ff46f46
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/schema/Utils.kt
@@ -0,0 +1,199 @@
+package org.jetbrains.kotlinx.dataframe.impl.schema
+
+import org.jetbrains.kotlinx.dataframe.AnyCol
+import org.jetbrains.kotlinx.dataframe.AnyFrame
+import org.jetbrains.kotlinx.dataframe.DataColumn
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.api.emptyDataFrame
+import org.jetbrains.kotlinx.dataframe.api.schema
+import org.jetbrains.kotlinx.dataframe.api.toDataFrame
+import org.jetbrains.kotlinx.dataframe.codeGen.MarkersExtractor
+import org.jetbrains.kotlinx.dataframe.columns.ColumnGroup
+import org.jetbrains.kotlinx.dataframe.columns.ColumnKind
+import org.jetbrains.kotlinx.dataframe.columns.FrameColumn
+import org.jetbrains.kotlinx.dataframe.columns.ValueColumn
+import org.jetbrains.kotlinx.dataframe.hasNulls
+import org.jetbrains.kotlinx.dataframe.impl.columnName
+import org.jetbrains.kotlinx.dataframe.impl.commonType
+import org.jetbrains.kotlinx.dataframe.impl.isGetterLike
+import org.jetbrains.kotlinx.dataframe.schema.ColumnSchema
+import org.jetbrains.kotlinx.dataframe.schema.DataFrameSchema
+import org.jetbrains.kotlinx.dataframe.type
+import kotlin.reflect.KCallable
+import kotlin.reflect.KClass
+import kotlin.reflect.full.primaryConstructor
+import kotlin.reflect.full.withNullability
+import kotlin.reflect.typeOf
+
+internal fun AnyFrame.extractSchema(): DataFrameSchema =
+    DataFrameSchemaImpl(columns().filter { it.name().isNotEmpty() }.associate { it.name() to it.extractSchema() })
+
+internal fun Iterable<DataFrameSchema>.intersectSchemas(): DataFrameSchema {
+    val collectedTypes = mutableMapOf<String, MutableSet<ColumnSchema>>()
+    var first = true
+    val columnsToUpdate = mutableSetOf<String>()
+    forEach { schema ->
+        if (first) {
+            schema.columns.forEach { (name, columnSchema) ->
+                collectedTypes[name] = mutableSetOf(columnSchema)
+            }
+            first = false
+        } else {
+            collectedTypes.forEach { (name, columnSchemas) ->
+                val otherType = schema.columns[name]
+                if (otherType == null) {
+                    columnsToUpdate.add(name)
+                } else {
+                    columnSchemas.add(otherType)
+                }
+            }
+            columnsToUpdate.forEach { collectedTypes.remove(it) }
+            columnsToUpdate.clear()
+        }
+    }
+    val result = collectedTypes.mapValues { (name, columnSchemas) ->
+        val columnKinds = columnSchemas.map { it.kind }.distinct()
+        val kind = columnKinds.first()
+        when {
+            columnKinds.size > 1 -> ColumnSchema.Value(typeOf<Any>().withNullability(columnSchemas.any { it.nullable }))
+
+            kind == ColumnKind.Value -> ColumnSchema.Value(
+                type = columnSchemas
+                    .map { (it as ColumnSchema.Value).type }
+                    .toSet()
+                    .commonType(),
+            )
+
+            kind == ColumnKind.Frame -> ColumnSchema.Frame(
+                // intersect only not empty schemas
+                schema = columnSchemas
+                    .mapNotNull { (it as ColumnSchema.Frame).schema.takeIf { it.columns.isNotEmpty() } }
+                    .intersectSchemas(),
+                nullable = columnSchemas.any { it.nullable },
+                contentType = columnSchemas
+                    .mapNotNull { (it as ColumnSchema.Frame).contentType }
+                    .toSet()
+                    .commonType(),
+            )
+
+            kind == ColumnKind.Group -> ColumnSchema.Group(
+                schema = columnSchemas.map { (it as ColumnSchema.Group).schema }
+                    .intersectSchemas(),
+                contentType = columnSchemas
+                    .mapNotNull { (it as ColumnSchema.Group).contentType }
+                    .toSet()
+                    .commonType(),
+            )
+
+            else -> throw RuntimeException()
+        }
+    }
+    return DataFrameSchemaImpl(result)
+}
+
+internal fun AnyCol.extractSchema(): ColumnSchema =
+    when (this) {
+        is ValueColumn<*> -> ColumnSchema.Value(type)
+        is ColumnGroup<*> -> ColumnSchema.Group(schema(), typeOf<Any?>())
+        is FrameColumn<*> -> ColumnSchema.Frame(schema.value, hasNulls, typeOf<Any?>())
+        else -> throw RuntimeException("Unknown column type: $this")
+    }
+
+@PublishedApi
+internal fun getSchema(kClass: KClass<*>): DataFrameSchema = MarkersExtractor.get(kClass).schema
+
+/**
+ * Create "empty" column based on the toplevel of [this] [ColumnSchema].
+ */
+internal fun ColumnSchema.createEmptyColumn(name: String): AnyCol =
+    when (this) {
+        is ColumnSchema.Value -> DataColumn.createValueColumn<Any?>(name, emptyList(), type)
+        is ColumnSchema.Group -> DataColumn.createColumnGroup(name, schema.createEmptyDataFrame()) as AnyCol
+        is ColumnSchema.Frame -> DataColumn.createFrameColumn<Any?>(name, emptyList(), lazyOf(schema))
+        else -> error("Unexpected ColumnSchema: $this")
+    }
+
+/**
+ * Creates a column based on [this] [ColumnSchema] filled with `null` or empty dataframes.
+ * @throws IllegalStateException if the column is not nullable and [numberOfRows]` > 0`.
+ */
+internal fun ColumnSchema.createNullFilledColumn(name: String, numberOfRows: Int): AnyCol =
+    when (this) {
+        is ColumnSchema.Value -> {
+            if (!type.isMarkedNullable && numberOfRows > 0) {
+                error("Cannot create a null-filled value column of type $type as it's not nullable.")
+            }
+            DataColumn.createValueColumn(
+                name = name,
+                values = List(numberOfRows) { null },
+                type = type,
+            )
+        }
+
+        is ColumnSchema.Group -> DataColumn.createColumnGroup(
+            name = name,
+            df = schema.createEmptyDataFrame(numberOfRows),
+        ) as AnyCol
+
+        is ColumnSchema.Frame -> DataColumn.createFrameColumn(
+            name = name,
+            groups = List(numberOfRows) { emptyDataFrame<Any?>() },
+            schema = lazyOf(schema),
+        )
+
+        else -> error("Cannot create null-filled column of unexpected ColumnSchema: $this")
+    }
+
+internal fun DataFrameSchema.createEmptyDataFrame(): AnyFrame =
+    columns.map { (name, schema) ->
+        schema.createEmptyColumn(name)
+    }.toDataFrame()
+
+internal fun DataFrameSchema.createEmptyDataFrame(numberOfRows: Int): AnyFrame =
+    if (columns.isEmpty()) {
+        DataFrame.empty(numberOfRows)
+    } else {
+        columns.map { (name, schema) ->
+            schema.createNullFilledColumn(name, numberOfRows)
+        }.toDataFrame()
+    }
+
+@PublishedApi
+internal fun createEmptyDataFrameOf(clazz: KClass<*>): AnyFrame =
+    MarkersExtractor.get(clazz).schema.createEmptyDataFrame()
+
+/**
+ * Returns a map of property names to their order in the primary/single constructor, if it exists,
+ * `null` otherwise.
+ */
+internal fun getPropertyOrderFromPrimaryConstructor(clazz: KClass<*>): Map<String, Int>? =
+    (clazz.primaryConstructor ?: clazz.constructors.singleOrNull())
+        ?.parameters
+        ?.mapNotNull { it.name }
+        ?.mapIndexed { i, v -> v to i }
+        ?.toMap()
+
+/**
+ * Sorts [this] according to the order of their [columnName] in the primary/single constructor of [klass]
+ * if it exists, else, it falls back to lexicographical sorting.
+ */
+internal fun <T> Iterable<KCallable<T>>.sortWithConstructor(klass: KClass<*>): List<KCallable<T>> {
+    require(all { it.isGetterLike() })
+    val primaryConstructorOrder = getPropertyOrderFromPrimaryConstructor(klass)
+
+    // starting off lexicographically
+    val lexicographicalColumns = sortedBy { it.columnName }
+
+    // if no primary constructor, return lexicographical order
+    if (primaryConstructorOrder == null) {
+        return lexicographicalColumns
+    }
+
+    // else sort the ones in the primary constructor first according to the order in there
+    // leave the rest at the end in lexicographical order
+    val (propsInConstructor, propsNotInConstructor) =
+        lexicographicalColumns.partition { it.columnName in primaryConstructorOrder.keys }
+
+    return propsInConstructor
+        .sortedBy { primaryConstructorOrder[it.columnName] } + propsNotInConstructor
+}
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/io/NameRepairStrategy.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/io/NameRepairStrategy.kt
new file mode 100644
index 000000000..9591f3929
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/io/NameRepairStrategy.kt
@@ -0,0 +1,16 @@
+package org.jetbrains.kotlinx.dataframe.io
+
+/**
+ * This strategy defines how the repeatable name column will be handled
+ * during the creation new dataframe from the IO sources.
+ */
+public enum class NameRepairStrategy {
+    /** No actions, keep as is. */
+    DO_NOTHING,
+
+    /** Check the uniqueness of the column names without any actions. */
+    CHECK_UNIQUE,
+
+    /** Check the uniqueness of the column names and repair it. */
+    MAKE_UNIQUE,
+}
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/io/common.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/io/common.kt
new file mode 100644
index 000000000..9c06fc58a
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/io/common.kt
@@ -0,0 +1,66 @@
+package org.jetbrains.kotlinx.dataframe.io
+
+import com.github.kittinunf.fuel.httpGet
+import org.jetbrains.kotlinx.dataframe.AnyFrame
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.api.toDataFrame
+import org.jetbrains.kotlinx.dataframe.impl.columns.guessColumnType
+import java.io.File
+import java.io.IOException
+import java.io.InputStream
+import java.net.URL
+
+internal fun catchHttpResponse(url: URL, body: (InputStream) -> AnyFrame): AnyFrame {
+    try {
+        return url.openStream().use(body)
+    } catch (e: IOException) {
+        if (e.message?.startsWith("Server returned HTTP response code") == true) {
+            val (_, response, _) = url.toString().httpGet().responseString()
+            try {
+                return DataFrame.readJsonStr(response.data.decodeToString())
+            } catch (e2: Exception) {
+                throw e
+            }
+        }
+        throw e
+    }
+}
+
+public fun <T> List<List<T>>.toDataFrame(containsColumns: Boolean = false): AnyFrame =
+    when {
+        containsColumns -> {
+            mapNotNull {
+                if (it.isEmpty()) return@mapNotNull null
+                val name = it[0].toString()
+                val values = it.drop(1)
+                guessColumnType(name, values)
+            }.toDataFrame()
+        }
+
+        isEmpty() -> DataFrame.Empty
+
+        else -> {
+            val header = get(0).map { it.toString() }
+            val data = drop(1)
+            header.mapIndexed { colIndex, name ->
+                val values = data.map { row ->
+                    if (row.size <= colIndex) {
+                        null
+                    } else {
+                        row[colIndex]
+                    }
+                }
+                guessColumnType(name, values)
+            }.toDataFrame()
+        }
+    }
+
+public fun isURL(path: String): Boolean = listOf("http:", "https:", "ftp:").any { path.startsWith(it) }
+
+public fun isFile(url: URL): Boolean = url.protocol == "file"
+
+public fun asFileOrNull(url: URL): File? = if (isFile(url)) File(url.path) else null
+
+public fun urlAsFile(url: URL): File = File(url.toURI())
+
+public fun isProtocolSupported(url: URL): Boolean = url.protocol in setOf("http", "https", "ftp")
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/io/csv.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/io/csv.kt
new file mode 100644
index 000000000..3dafb4723
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/io/csv.kt
@@ -0,0 +1,416 @@
+package org.jetbrains.kotlinx.dataframe.io
+
+import kotlinx.datetime.LocalDate
+import kotlinx.datetime.LocalDateTime
+import kotlinx.datetime.LocalTime
+import org.apache.commons.csv.CSVFormat
+import org.apache.commons.csv.CSVRecord
+import org.apache.commons.io.input.BOMInputStream
+import org.jetbrains.kotlinx.dataframe.AnyFrame
+import org.jetbrains.kotlinx.dataframe.AnyRow
+import org.jetbrains.kotlinx.dataframe.DataColumn
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.annotations.Interpretable
+import org.jetbrains.kotlinx.dataframe.annotations.OptInRefine
+import org.jetbrains.kotlinx.dataframe.annotations.Refine
+import org.jetbrains.kotlinx.dataframe.api.ParserOptions
+import org.jetbrains.kotlinx.dataframe.api.forEach
+import org.jetbrains.kotlinx.dataframe.api.toDataFrame
+import org.jetbrains.kotlinx.dataframe.api.tryParse
+import org.jetbrains.kotlinx.dataframe.codeGen.DefaultReadCsvMethod
+import org.jetbrains.kotlinx.dataframe.codeGen.DefaultReadDfMethod
+import org.jetbrains.kotlinx.dataframe.impl.ColumnNameGenerator
+import org.jetbrains.kotlinx.dataframe.impl.api.Parsers
+import org.jetbrains.kotlinx.dataframe.impl.api.parse
+import org.jetbrains.kotlinx.dataframe.util.DF_READ_NO_CSV
+import org.jetbrains.kotlinx.dataframe.util.DF_READ_NO_CSV_REPLACE
+import org.jetbrains.kotlinx.dataframe.values
+import java.io.BufferedInputStream
+import java.io.BufferedReader
+import java.io.File
+import java.io.FileInputStream
+import java.io.FileWriter
+import java.io.IOException
+import java.io.InputStream
+import java.io.InputStreamReader
+import java.io.Reader
+import java.io.StringReader
+import java.io.StringWriter
+import java.math.BigDecimal
+import java.net.URL
+import java.nio.charset.Charset
+import java.util.zip.GZIPInputStream
+import kotlin.reflect.KClass
+import kotlin.reflect.full.withNullability
+import kotlin.reflect.typeOf
+
+public class CSV(private val delimiter: Char = ',') : SupportedDataFrameFormat {
+    override fun readDataFrame(stream: InputStream, header: List<String>): AnyFrame =
+        DataFrame.readCSV(stream = stream, delimiter = delimiter, header = header)
+
+    override fun readDataFrame(file: File, header: List<String>): AnyFrame =
+        DataFrame.readCSV(file = file, delimiter = delimiter, header = header)
+
+    override fun acceptsExtension(ext: String): Boolean = ext == "csv"
+
+    override fun acceptsSample(sample: SupportedFormatSample): Boolean = true // Extension is enough
+
+    override val testOrder: Int = 20000
+
+    override fun createDefaultReadMethod(pathRepresentation: String?): DefaultReadDfMethod {
+        val arguments = MethodArguments().add("delimiter", typeOf<Char>(), "'%L'", delimiter)
+        return DefaultReadCsvMethod(pathRepresentation, arguments)
+    }
+}
+
+public enum class CSVType(public val format: CSVFormat) {
+    DEFAULT(
+        CSVFormat.DEFAULT.builder()
+            .setAllowMissingColumnNames(true)
+            .setIgnoreSurroundingSpaces(true)
+            .build(),
+    ),
+    TDF(
+        CSVFormat.TDF.builder()
+            .setAllowMissingColumnNames(true)
+            .build(),
+    ),
+}
+
+private val defaultCharset = Charsets.UTF_8
+
+internal fun isCompressed(fileOrUrl: String) = listOf("gz", "zip").contains(fileOrUrl.split(".").last())
+
+internal fun isCompressed(file: File) = listOf("gz", "zip").contains(file.extension)
+
+internal fun isCompressed(url: URL) = isCompressed(url.path)
+
+@Refine
+@Interpretable("ReadDelimStr")
+public fun DataFrame.Companion.readDelimStr(
+    text: String,
+    delimiter: Char = ',',
+    colTypes: Map<String, ColType> = mapOf(),
+    skipLines: Int = 0,
+    readLines: Int? = null,
+): DataFrame<*> =
+    StringReader(text).use {
+        val format = CSVType.DEFAULT.format.builder()
+            .setHeader()
+            .setDelimiter(delimiter)
+            .build()
+        readDelim(it, format, colTypes, skipLines, readLines)
+    }
+
+@Deprecated(
+    message = DF_READ_NO_CSV,
+    replaceWith = ReplaceWith(DF_READ_NO_CSV_REPLACE),
+    level = DeprecationLevel.WARNING,
+)
+public fun DataFrame.Companion.read(
+    fileOrUrl: String,
+    delimiter: Char,
+    header: List<String> = listOf(),
+    colTypes: Map<String, ColType> = mapOf(),
+    skipLines: Int = 0,
+    readLines: Int? = null,
+    duplicate: Boolean = true,
+    charset: Charset = Charsets.UTF_8,
+): DataFrame<*> =
+    catchHttpResponse(asURL(fileOrUrl)) {
+        readDelim(
+            it,
+            delimiter,
+            header,
+            isCompressed(fileOrUrl),
+            getCSVType(fileOrUrl),
+            colTypes,
+            skipLines,
+            readLines,
+            duplicate,
+            charset,
+        )
+    }
+
+@OptInRefine
+@Interpretable("ReadCSV0")
+public fun DataFrame.Companion.readCSV(
+    fileOrUrl: String,
+    delimiter: Char = ',',
+    header: List<String> = listOf(),
+    colTypes: Map<String, ColType> = mapOf(),
+    skipLines: Int = 0,
+    readLines: Int? = null,
+    duplicate: Boolean = true,
+    charset: Charset = Charsets.UTF_8,
+    parserOptions: ParserOptions? = null,
+): DataFrame<*> =
+    catchHttpResponse(asURL(fileOrUrl)) {
+        readDelim(
+            it,
+            delimiter,
+            header,
+            isCompressed(fileOrUrl),
+            CSVType.DEFAULT,
+            colTypes,
+            skipLines,
+            readLines,
+            duplicate,
+            charset,
+            parserOptions,
+        )
+    }
+
+public fun DataFrame.Companion.readCSV(
+    file: File,
+    delimiter: Char = ',',
+    header: List<String> = listOf(),
+    colTypes: Map<String, ColType> = mapOf(),
+    skipLines: Int = 0,
+    readLines: Int? = null,
+    duplicate: Boolean = true,
+    charset: Charset = Charsets.UTF_8,
+    parserOptions: ParserOptions? = null,
+): DataFrame<*> =
+    readDelim(
+        FileInputStream(file),
+        delimiter,
+        header,
+        isCompressed(file),
+        CSVType.DEFAULT,
+        colTypes,
+        skipLines,
+        readLines,
+        duplicate,
+        charset,
+        parserOptions,
+    )
+
+public fun DataFrame.Companion.readCSV(
+    url: URL,
+    delimiter: Char = ',',
+    header: List<String> = listOf(),
+    colTypes: Map<String, ColType> = mapOf(),
+    skipLines: Int = 0,
+    readLines: Int? = null,
+    duplicate: Boolean = true,
+    charset: Charset = Charsets.UTF_8,
+    parserOptions: ParserOptions? = null,
+): DataFrame<*> =
+    readCSV(
+        url.openStream(),
+        delimiter,
+        header,
+        isCompressed(url),
+        colTypes,
+        skipLines,
+        readLines,
+        duplicate,
+        charset,
+        parserOptions,
+    )
+
+public fun DataFrame.Companion.readCSV(
+    stream: InputStream,
+    delimiter: Char = ',',
+    header: List<String> = listOf(),
+    isCompressed: Boolean = false,
+    colTypes: Map<String, ColType> = mapOf(),
+    skipLines: Int = 0,
+    readLines: Int? = null,
+    duplicate: Boolean = true,
+    charset: Charset = Charsets.UTF_8,
+    parserOptions: ParserOptions? = null,
+): DataFrame<*> =
+    readDelim(
+        stream,
+        delimiter,
+        header,
+        isCompressed,
+        CSVType.DEFAULT,
+        colTypes,
+        skipLines,
+        readLines,
+        duplicate,
+        charset,
+        parserOptions,
+    )
+
+private fun getCSVType(path: String): CSVType =
+    when (path.substringAfterLast('.').lowercase()) {
+        "csv" -> CSVType.DEFAULT
+        "tdf" -> CSVType.TDF
+        else -> throw IOException("Unknown file format")
+    }
+
+private fun asStream(fileOrUrl: String) =
+    if (isURL(fileOrUrl)) {
+        URL(fileOrUrl).toURI()
+    } else {
+        File(fileOrUrl).toURI()
+    }.toURL().openStream()
+
+public fun asURL(fileOrUrl: String): URL =
+    if (isURL(fileOrUrl)) {
+        URL(fileOrUrl).toURI()
+    } else {
+        File(fileOrUrl).toURI()
+    }.toURL()
+
+private fun getFormat(
+    type: CSVType,
+    delimiter: Char,
+    header: List<String>,
+    duplicate: Boolean,
+): CSVFormat =
+    type.format.builder()
+        .setDelimiter(delimiter)
+        .setHeader(*header.toTypedArray())
+        .setAllowMissingColumnNames(duplicate)
+        .build()
+
+public fun DataFrame.Companion.readDelim(
+    inStream: InputStream,
+    delimiter: Char = ',',
+    header: List<String> = listOf(),
+    isCompressed: Boolean = false,
+    csvType: CSVType,
+    colTypes: Map<String, ColType> = mapOf(),
+    skipLines: Int = 0,
+    readLines: Int? = null,
+    duplicate: Boolean = true,
+    charset: Charset = defaultCharset,
+    parserOptions: ParserOptions? = null,
+): AnyFrame {
+    val bufferedInStream = BufferedInputStream(if (isCompressed) GZIPInputStream(inStream) else inStream)
+    val bomIn = BOMInputStream.builder().setInputStream(bufferedInStream).get()
+    val bufferedReader = BufferedReader(InputStreamReader(bomIn, charset))
+
+    return readDelim(
+        reader = bufferedReader,
+        format = getFormat(csvType, delimiter, header, duplicate),
+        colTypes = colTypes,
+        skipLines = skipLines,
+        readLines = readLines,
+        parserOptions = parserOptions,
+    )
+}
+
+public enum class ColType {
+    Int,
+    Long,
+    Double,
+    Boolean,
+    BigDecimal,
+    LocalDate,
+    LocalTime,
+    LocalDateTime,
+    String,
+}
+
+public fun ColType.toType(): KClass<out Any> =
+    when (this) {
+        ColType.Int -> Int::class
+        ColType.Long -> Long::class
+        ColType.Double -> Double::class
+        ColType.Boolean -> Boolean::class
+        ColType.BigDecimal -> BigDecimal::class
+        ColType.LocalDate -> LocalDate::class
+        ColType.LocalTime -> LocalTime::class
+        ColType.LocalDateTime -> LocalDateTime::class
+        ColType.String -> String::class
+    }
+
+public fun DataFrame.Companion.readDelim(
+    reader: Reader,
+    format: CSVFormat = CSVFormat.DEFAULT.builder()
+        .setHeader()
+        .build(),
+    colTypes: Map<String, ColType> = mapOf(),
+    skipLines: Int = 0,
+    readLines: Int? = null,
+    parserOptions: ParserOptions? = null,
+): AnyFrame {
+    var reader = reader
+    if (skipLines > 0) {
+        reader = BufferedReader(reader)
+        repeat(skipLines) { reader.readLine() }
+    }
+
+    val csvParser = format.parse(reader)
+    val records = if (readLines == null) {
+        csvParser.records
+    } else {
+        require(readLines >= 0) { "`readLines` must not be negative" }
+        val records = ArrayList<CSVRecord>(readLines)
+        val iter = csvParser.iterator()
+        var count = readLines ?: 0
+        while (iter.hasNext() && 0 < count--) {
+            records.add(iter.next())
+        }
+        records
+    }
+
+    val columnNames = csvParser.headerNames.takeIf { it.isNotEmpty() }
+        ?: (1..(records.firstOrNull()?.count() ?: 0)).map { index -> "X$index" }
+
+    val generator = ColumnNameGenerator()
+    val uniqueNames = columnNames.map { generator.addUnique(it) }
+
+    val cols = uniqueNames.mapIndexed { colIndex, colName ->
+        val defaultColType = colTypes[".default"]
+        val colType = colTypes[colName] ?: defaultColType
+        var hasNulls = false
+        val values = records.map {
+            if (it.isSet(colIndex)) {
+                it[colIndex].ifEmpty {
+                    hasNulls = true
+                    null
+                }
+            } else {
+                hasNulls = true
+                null
+            }
+        }
+        val column = DataColumn.createValueColumn(colName, values, typeOf<String>().withNullability(hasNulls))
+        when (colType) {
+            null -> column.tryParse(parserOptions)
+
+            else -> {
+                val parser = Parsers[colType.toType()]!!
+                column.parse(parser, parserOptions)
+            }
+        }
+    }
+    return cols.toDataFrame()
+}
+
+public fun AnyFrame.writeCSV(file: File, format: CSVFormat = CSVFormat.DEFAULT): Unit =
+    writeCSV(FileWriter(file), format)
+
+public fun AnyFrame.writeCSV(path: String, format: CSVFormat = CSVFormat.DEFAULT): Unit =
+    writeCSV(FileWriter(path), format)
+
+public fun AnyFrame.writeCSV(writer: Appendable, format: CSVFormat = CSVFormat.DEFAULT) {
+    format.print(writer).use { printer ->
+        if (!format.skipHeaderRecord) {
+            printer.printRecord(columnNames())
+        }
+        forEach {
+            val values = it.values.map {
+                when (it) {
+                    is AnyRow -> it.toJson()
+                    is AnyFrame -> it.toJson()
+                    else -> it
+                }
+            }
+            printer.printRecord(values)
+        }
+    }
+}
+
+public fun AnyFrame.toCsv(format: CSVFormat = CSVFormat.DEFAULT): String =
+    StringWriter().use {
+        this.writeCSV(it, format)
+        it
+    }.toString()
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/io/guess.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/io/guess.kt
new file mode 100644
index 000000000..77ffa8a69
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/io/guess.kt
@@ -0,0 +1,299 @@
+package org.jetbrains.kotlinx.dataframe.io
+
+import com.squareup.kotlinpoet.PropertySpec
+import com.squareup.kotlinpoet.asTypeName
+import org.jetbrains.kotlinx.dataframe.AnyFrame
+import org.jetbrains.kotlinx.dataframe.AnyRow
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.DataRow
+import org.jetbrains.kotlinx.dataframe.annotations.DataSchema
+import org.jetbrains.kotlinx.dataframe.annotations.ImportDataSchema
+import org.jetbrains.kotlinx.dataframe.annotations.Interpretable
+import org.jetbrains.kotlinx.dataframe.annotations.OptInRefine
+import org.jetbrains.kotlinx.dataframe.api.single
+import org.jetbrains.kotlinx.dataframe.codeGen.DefaultReadDfMethod
+import org.jetbrains.kotlinx.jupyter.api.Code
+import java.io.BufferedInputStream
+import java.io.File
+import java.io.FileNotFoundException
+import java.io.InputStream
+import java.net.URL
+import java.util.ServiceLoader
+import kotlin.reflect.KType
+
+public sealed interface SupportedFormat {
+
+    public fun acceptsExtension(ext: String): Boolean
+
+    public fun acceptsSample(sample: SupportedFormatSample): Boolean
+
+    // `DataFrame.Companion.read` methods uses this to sort list of all supported formats in ascending order (-1, 2, 10)
+    // sorted list is used to test if any format can read given input
+    public val testOrder: Int
+
+    public fun createDefaultReadMethod(pathRepresentation: String? = null): DefaultReadDfMethod
+}
+
+public sealed interface SupportedFormatSample {
+
+    @JvmInline
+    public value class DataFile(public val sampleFile: File) : SupportedFormatSample
+
+    @JvmInline
+    public value class DataUrl(public val sampleUrl: URL) : SupportedFormatSample
+
+    @JvmInline
+    public value class PathString(public val samplePath: String) : SupportedFormatSample
+
+    @JvmInline
+    public value class DataString(public val sampleData: String) : SupportedFormatSample
+}
+
+/**
+ * Implement this interface to provide additional supported formats for DataFrames (such as JSON, XML, CSV, etc.).
+ * A [SupportedDataFrameFormat] is read directly to a DataFrame. If specified using
+ * [ImportDataSchema] or using the Gradle plugin, the read DataFrame will be used to
+ * generate [DataSchema] interfaces.
+ */
+public interface SupportedDataFrameFormat : SupportedFormat {
+    public fun readDataFrame(stream: InputStream, header: List<String> = emptyList()): DataFrame<*>
+
+    public fun readDataFrame(file: File, header: List<String> = emptyList()): DataFrame<*>
+}
+
+/**
+ * Implement this interface to provide additional [DataSchema] interface generation formats for DataFrames (such as OpenAPI).
+ * Note, this doesn't add functionality to [DataFrame.Companion.read], just [ImportDataSchema] and Gradle plugin.
+ *
+ * Return type will be a [Code] which contains a generated `interface` with the given name containing generated
+ * [DataSchema] interfaces and `enum`s, with `typealias`es (and optional extension functions in some integration)
+ * outside the interface.
+ */
+public interface SupportedCodeGenerationFormat : SupportedFormat {
+
+    /**
+     * @param stream where to read the schema from
+     * @param name the name of the top-level interface to generate
+     * @param generateHelperCompanionObject whether to generate a helper companion object (only needed for Jupyter)
+     */
+    public fun readCodeForGeneration(
+        stream: InputStream,
+        name: String,
+        generateHelperCompanionObject: Boolean = false,
+    ): Code
+
+    /**
+     * @param file where to read the schema from
+     * @param name the name of the top-level interface to generate
+     * @param generateHelperCompanionObject whether to generate a helper companion object (only needed for Jupyter)
+     */
+    public fun readCodeForGeneration(file: File, name: String, generateHelperCompanionObject: Boolean = false): Code
+}
+
+public class MethodArguments {
+    internal val defaultValues = mutableListOf<Argument>()
+
+    public fun add(
+        name: String,
+        type: KType,
+        initializerTemplate: String,
+        vararg values: Any?,
+    ): MethodArguments {
+        val capitalizedName = name.replaceFirstChar { it.uppercaseChar() }
+        val propertyName = "default$capitalizedName"
+
+        val property = PropertySpec
+            .builder(propertyName, type.asTypeName())
+            .initializer(initializerTemplate, args = values)
+            .build()
+
+        defaultValues += Argument(name, property)
+        return this
+    }
+
+    internal class Argument(val name: String, val property: PropertySpec)
+
+    public companion object {
+        public val EMPTY: MethodArguments get() = MethodArguments()
+    }
+}
+
+/**
+ * NOTE: Needs to have fully qualified name in
+ * resources/META-INF/services/org.jetbrains.kotlinx.dataframe.io.SupportedFormat
+ * to be detected here.
+ */
+internal val supportedFormats: List<SupportedFormat> by lazy {
+    (
+        ServiceLoader.load(SupportedDataFrameFormat::class.java).toList() +
+            ServiceLoader.load(SupportedCodeGenerationFormat::class.java).toList() +
+            ServiceLoader.load(SupportedFormat::class.java).toList()
+    ).distinct()
+        .sortedBy { it.testOrder }
+}
+
+internal fun guessFormatForExtension(
+    ext: String,
+    formats: List<SupportedFormat> = supportedFormats,
+    sample: SupportedFormatSample? = null,
+): SupportedFormat? = formats.firstOrNull { it.acceptsExtension(ext) && (sample == null || it.acceptsSample(sample)) }
+
+internal fun guessFormat(
+    file: File,
+    formats: List<SupportedFormat> = supportedFormats,
+    sample: SupportedFormatSample.DataFile? = SupportedFormatSample.DataFile(file),
+): SupportedFormat? = guessFormatForExtension(file.extension.lowercase(), formats, sample = sample)
+
+internal fun guessFormat(
+    url: URL,
+    formats: List<SupportedFormat> = supportedFormats,
+    sample: SupportedFormatSample.DataUrl? = SupportedFormatSample.DataUrl(url),
+): SupportedFormat? = guessFormatForExtension(url.path.substringAfterLast("."), formats, sample = sample)
+
+internal fun guessFormat(
+    path: String,
+    formats: List<SupportedFormat> = supportedFormats,
+    sample: SupportedFormatSample.PathString? = SupportedFormatSample.PathString(path),
+): SupportedFormat? = guessFormatForExtension(path.substringAfterLast("."), formats, sample = sample)
+
+private class NotCloseableStream(val src: InputStream) : InputStream() {
+    override fun read(): Int = src.read()
+
+    fun doClose() = src.close()
+
+    override fun reset() = src.reset()
+
+    override fun available() = src.available()
+
+    override fun markSupported() = src.markSupported()
+
+    override fun mark(readlimit: Int) = src.mark(readlimit)
+}
+
+/**
+ * @param stream where to read the schema from
+ * @param name the name of the top-level interface to generate
+ * @param format the format to use
+ * @param generateHelperCompanionObject whether to generate a helper companion object (only needed for Jupyter)
+ * @param formats Optional list of supported formats to use. If not specified, all formats will be used.
+ *
+ * @return [GeneratedCode] with generated code
+ */
+internal fun readCodeForGeneration(
+    stream: InputStream,
+    name: String,
+    format: SupportedCodeGenerationFormat? = null,
+    generateHelperCompanionObject: Boolean = false,
+    formats: List<SupportedCodeGenerationFormat> = supportedFormats.filterIsInstance<SupportedCodeGenerationFormat>(),
+): GeneratedCode {
+    if (format != null) return format to format.readCodeForGeneration(stream, name, generateHelperCompanionObject)
+    val input = NotCloseableStream(if (stream.markSupported()) stream else BufferedInputStream(stream))
+    try {
+        val readLimit = 10000
+        input.mark(readLimit)
+
+        formats.sortedBy { it.testOrder }.forEach {
+            try {
+                input.reset()
+                return it to it.readCodeForGeneration(input, name, generateHelperCompanionObject)
+            } catch (_: Exception) {
+            }
+        }
+        throw IllegalArgumentException("Unknown stream format")
+    } finally {
+        input.doClose()
+    }
+}
+
+internal fun DataFrame.Companion.read(
+    stream: InputStream,
+    format: SupportedDataFrameFormat? = null,
+    header: List<String> = emptyList(),
+    formats: List<SupportedDataFrameFormat> = supportedFormats.filterIsInstance<SupportedDataFrameFormat>(),
+): ReadAnyFrame {
+    if (format != null) return format to format.readDataFrame(stream, header = header)
+    stream.use { input ->
+        val byteArray = input.readBytes() // read 8192 bytes
+        formats.sortedBy { it.testOrder }.forEach {
+            try {
+                return it to it.readDataFrame(byteArray.inputStream(), header = header)
+            } catch (_: Exception) {
+            }
+        }
+        throw IllegalArgumentException("Unknown stream format; Tried $formats")
+    }
+}
+
+internal fun DataFrame.Companion.read(
+    file: File,
+    format: SupportedDataFrameFormat? = null,
+    header: List<String> = emptyList(),
+    formats: List<SupportedDataFrameFormat> = supportedFormats.filterIsInstance<SupportedDataFrameFormat>(),
+): ReadAnyFrame {
+    if (format != null) return format to format.readDataFrame(file, header = header)
+    formats.sortedBy { it.testOrder }.forEach {
+        try {
+            return it to it.readDataFrame(file, header = header)
+        } catch (e: FileNotFoundException) {
+            throw e
+        } catch (e: Exception) {
+        }
+    }
+    throw IllegalArgumentException("Unknown file format; Tried $formats")
+}
+
+internal data class ReadAnyFrame(val format: SupportedDataFrameFormat, val df: AnyFrame)
+
+internal infix fun SupportedDataFrameFormat.to(df: AnyFrame) = ReadAnyFrame(this, df)
+
+internal data class GeneratedCode(val format: SupportedCodeGenerationFormat, val code: Code)
+
+internal infix fun SupportedCodeGenerationFormat.to(code: Code) = GeneratedCode(this, code)
+
+public fun DataFrame.Companion.read(file: File, header: List<String> = emptyList()): AnyFrame =
+    read(
+        file = file,
+        format = guessFormat(file)?.also {
+            if (it !is SupportedDataFrameFormat) error("Format $it does not support reading dataframes")
+        } as SupportedDataFrameFormat?,
+        header = header,
+    ).df
+
+public fun DataRow.Companion.read(file: File, header: List<String> = emptyList()): AnyRow =
+    DataFrame.read(file, header).single()
+
+public fun DataFrame.Companion.read(url: URL, header: List<String> = emptyList()): AnyFrame =
+    when {
+        isFile(url) -> read(urlAsFile(url), header)
+
+        isProtocolSupported(url) -> catchHttpResponse(url) {
+            read(
+                stream = it,
+                format = guessFormat(url)?.also {
+                    if (it !is SupportedDataFrameFormat) error("Format $it does not support reading dataframes")
+                } as SupportedDataFrameFormat?,
+                header = header,
+            ).df
+        }
+
+        else -> throw IllegalArgumentException("Invalid protocol for url $url")
+    }
+
+public fun DataRow.Companion.read(url: URL, header: List<String> = emptyList()): AnyRow =
+    DataFrame.read(url, header).single()
+
+@OptInRefine
+@Interpretable("Read0")
+public fun DataFrame.Companion.read(path: String, header: List<String> = emptyList()): AnyFrame =
+    read(asURL(path), header)
+
+public fun DataRow.Companion.read(path: String, header: List<String> = emptyList()): AnyRow =
+    DataFrame.read(path, header).single()
+
+public fun URL.readDataFrame(header: List<String> = emptyList()): AnyFrame = DataFrame.read(this, header)
+
+public fun URL.readDataRow(header: List<String> = emptyList()): AnyRow = DataRow.read(this, header)
+
+public fun File.readDataFrame(header: List<String> = emptyList()): AnyFrame = DataFrame.read(this, header)
+
+public fun File.readDataRow(header: List<String> = emptyList()): AnyRow = DataRow.read(this, header)
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/io/html.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/io/html.kt
new file mode 100644
index 000000000..ed42b595f
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/io/html.kt
@@ -0,0 +1,869 @@
+package org.jetbrains.kotlinx.dataframe.io
+
+import org.intellij.lang.annotations.Language
+import org.jetbrains.kotlinx.dataframe.AnyCol
+import org.jetbrains.kotlinx.dataframe.AnyFrame
+import org.jetbrains.kotlinx.dataframe.AnyRow
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.api.FormattingDSL
+import org.jetbrains.kotlinx.dataframe.api.RowColFormatter
+import org.jetbrains.kotlinx.dataframe.api.asColumnGroup
+import org.jetbrains.kotlinx.dataframe.api.asNumbers
+import org.jetbrains.kotlinx.dataframe.api.getColumnsWithPaths
+import org.jetbrains.kotlinx.dataframe.api.isColumnGroup
+import org.jetbrains.kotlinx.dataframe.api.isEmpty
+import org.jetbrains.kotlinx.dataframe.api.isNumber
+import org.jetbrains.kotlinx.dataframe.api.isSubtypeOf
+import org.jetbrains.kotlinx.dataframe.api.rows
+import org.jetbrains.kotlinx.dataframe.columns.BaseColumn
+import org.jetbrains.kotlinx.dataframe.columns.ColumnGroup
+import org.jetbrains.kotlinx.dataframe.columns.ColumnWithPath
+import org.jetbrains.kotlinx.dataframe.columns.FrameColumn
+import org.jetbrains.kotlinx.dataframe.impl.DataFrameSize
+import org.jetbrains.kotlinx.dataframe.impl.columns.addPath
+import org.jetbrains.kotlinx.dataframe.impl.io.resizeKeepingAspectRatio
+import org.jetbrains.kotlinx.dataframe.impl.renderType
+import org.jetbrains.kotlinx.dataframe.impl.scale
+import org.jetbrains.kotlinx.dataframe.impl.truncate
+import org.jetbrains.kotlinx.dataframe.jupyter.CellRenderer
+import org.jetbrains.kotlinx.dataframe.jupyter.DefaultCellRenderer
+import org.jetbrains.kotlinx.dataframe.jupyter.RenderedContent
+import org.jetbrains.kotlinx.dataframe.name
+import org.jetbrains.kotlinx.dataframe.nrow
+import org.jetbrains.kotlinx.dataframe.size
+import java.awt.Desktop
+import java.awt.image.BufferedImage
+import java.io.File
+import java.io.InputStreamReader
+import java.net.URL
+import java.nio.file.Path
+import java.util.LinkedList
+import java.util.Random
+import kotlin.io.path.writeText
+import kotlin.math.ceil
+
+internal val tooltipLimit = 1000
+
+internal interface CellContent
+
+internal data class DataFrameReference(val dfId: Int, val size: DataFrameSize) : CellContent
+
+internal data class HtmlContent(val html: String, val style: String?) : CellContent
+
+internal data class ColumnDataForJs(
+    val column: AnyCol,
+    val nested: List<ColumnDataForJs>,
+    val rightAlign: Boolean,
+    val values: List<CellContent>,
+)
+
+internal val formatter = DataFrameFormatter(
+    "formatted",
+    "null",
+    "structural",
+    "numbers",
+    "dataFrameCaption",
+)
+
+internal fun getResources(vararg resource: String) = resource.joinToString(separator = "\n") { getResourceText(it) }
+
+internal fun getResourceText(resource: String, vararg replacement: Pair<String, Any>): String {
+    val res = DataFrame::class.java.getResourceAsStream(resource) ?: error("Resource '$resource' not found")
+    var template = InputStreamReader(res).readText()
+    replacement.forEach {
+        template = template.replace(it.first, it.second.toString())
+    }
+    return template
+}
+
+internal fun ColumnDataForJs.renderHeader(): String {
+    val tooltip = "${column.name}: ${renderType(column.type())}"
+    return "<span title=\"$tooltip\">${column.name()}</span>"
+}
+
+internal fun tableJs(
+    columns: List<ColumnDataForJs>,
+    id: Int,
+    rootId: Int,
+    nrow: Int,
+): String {
+    var index = 0
+    val data = buildString {
+        append("[")
+
+        fun appendColWithChildren(col: ColumnDataForJs): Int {
+            val children = col.nested.map { appendColWithChildren(it) }
+            val colIndex = index++
+            val values = col.values.joinToString(",", prefix = "[", postfix = "]") {
+                when (it) {
+                    is HtmlContent -> {
+                        val html = "\"" + it.html.escapeForHtmlInJs() + "\""
+                        if (it.style == null) {
+                            html
+                        } else {
+                            "{ style: \"${it.style}\", value: $html}"
+                        }
+                    }
+
+                    is DataFrameReference -> {
+                        val text = "<b>DataFrame ${it.size}</b>"
+                        "{ frameId: ${it.dfId}, value: \"$text\" }"
+                    }
+
+                    else -> error("Unsupported value type: ${it.javaClass}")
+                }
+            }
+
+            val colName = col.renderHeader().escapeForHtmlInJs()
+            append("{ name: \"$colName\", children: $children, rightAlign: ${col.rightAlign}, values: $values }, \n")
+
+            return@appendColWithChildren colIndex
+        }
+        columns.forEach { appendColWithChildren(it) }
+        append("]")
+    }
+    val js = getResourceText(
+        "/addTable.js",
+        "___COLUMNS___" to data,
+        "___ID___" to id,
+        "___ROOT___" to rootId,
+        "___NROW___" to nrow,
+    )
+    return js
+}
+
+internal var tableInSessionId = 0
+internal var sessionId = (Random().nextInt() % 128) shl 24
+
+internal fun nextTableId() = sessionId + (tableInSessionId++)
+
+internal fun AnyFrame.toHtmlData(
+    configuration: DisplayConfiguration = DisplayConfiguration.DEFAULT,
+    cellRenderer: CellRenderer,
+): DataFrameHtmlData {
+    val scripts = mutableListOf<String>()
+    val queue = LinkedList<Pair<AnyFrame, Int>>()
+
+    fun AnyFrame.columnToJs(col: AnyCol, rowsLimit: Int?): ColumnDataForJs {
+        val values = if (rowsLimit != null) rows().take(rowsLimit) else rows()
+        val scale = if (col.isNumber()) col.asNumbers().scale() else 1
+        val format = if (scale > 0) {
+            RendererDecimalFormat.fromPrecision(scale)
+        } else {
+            RendererDecimalFormat.of("%e")
+        }
+        val renderConfig = configuration.copy(decimalFormat = format)
+        val contents = values.map {
+            val value = it[col]
+            if (value is AnyFrame) {
+                if (value.isEmpty()) {
+                    HtmlContent("", null)
+                } else {
+                    val id = nextTableId()
+                    queue.add(value to id)
+                    DataFrameReference(id, value.size)
+                }
+            } else {
+                val html =
+                    formatter.format(downsizeBufferedImageIfNeeded(value, renderConfig), cellRenderer, renderConfig)
+                val style = renderConfig.cellFormatter
+                    ?.invoke(FormattingDSL, it, col)
+                    ?.attributes()
+                    ?.ifEmpty { null }
+                    ?.joinToString(";") { "${it.first}:${it.second}" }
+                HtmlContent(html, style)
+            }
+        }
+        return ColumnDataForJs(
+            column = col,
+            nested = if (col is ColumnGroup<*>) col.columns().map { col.columnToJs(it, rowsLimit) } else emptyList(),
+            rightAlign = col.isSubtypeOf<Number?>(),
+            values = contents,
+        )
+    }
+
+    val rootId = nextTableId()
+    queue.add(this to rootId)
+    while (!queue.isEmpty()) {
+        val (nextDf, nextId) = queue.pop()
+        val rowsLimit = if (nextId == rootId) configuration.rowsLimit else configuration.nestedRowsLimit
+        val preparedColumns = nextDf.columns().map { nextDf.columnToJs(it, rowsLimit) }
+        val js = tableJs(preparedColumns, nextId, rootId, nextDf.nrow)
+        scripts.add(js)
+    }
+    val body = getResourceText("/table.html", "ID" to rootId)
+    val script = scripts.joinToString("\n") + "\n" + getResourceText("/renderTable.js", "___ID___" to rootId)
+    return DataFrameHtmlData(style = "", body = body, script = script)
+}
+
+private const val DEFAULT_HTML_IMG_SIZE = 100
+
+/**
+ * This method resizes a BufferedImage if necessary, according to the provided DisplayConfiguration.
+ * It is essential to prevent potential memory problems when serializing HTML data for display in the Kotlin Notebook plugin.
+ *
+ * @param value The input value to be checked and possibly downsized.
+ * @param renderConfig The DisplayConfiguration to determine if downsizing is needed.
+ * @return The downsized BufferedImage if value is a BufferedImage and downsizing is enabled in the DisplayConfiguration,
+ *         otherwise returns the input value unchanged.
+ */
+private fun downsizeBufferedImageIfNeeded(value: Any?, renderConfig: DisplayConfiguration): Any? =
+    when {
+        value is BufferedImage && renderConfig.downsizeBufferedImage -> {
+            value.resizeKeepingAspectRatio(DEFAULT_HTML_IMG_SIZE)
+        }
+
+        else -> value
+    }
+
+/**
+ * Renders [this] [DataFrame] as static HTML (meaning no JS is used).
+ * CSS rendering is enabled by default but can be turned off using [includeCss]
+ *
+ * @param configuration optional configuration for rendering
+ * @param cellRenderer optional cell renderer for rendering
+ * @param includeCss whether to include CSS in the output. This is `true` by default but it can be set
+ *  to `false` to emulate what happens in environments where custom CSS is not allowed.
+ * @param openNestedDfs whether to open nested dataframes. This is `false` by default byt ut can be set
+ *  to `true` to emulate what happens in environments where `<details>` tags are not supported.
+ */
+public fun AnyFrame.toStaticHtml(
+    configuration: DisplayConfiguration = DisplayConfiguration.DEFAULT,
+    cellRenderer: CellRenderer = DefaultCellRenderer,
+    includeCss: Boolean = true,
+    openNestedDfs: Boolean = false,
+): DataFrameHtmlData {
+    val df = this
+    val id = "static_df_${nextTableId()}"
+
+    // Retrieve all columns, including nested ones
+    val flattenedCols = getColumnsWithPaths { colsAtAnyDepth { !it.isColumnGroup() } }
+
+    // Get a grid of columns for the header, as well as the side borders for each cell
+    val colGrid = getColumnsHeaderGrid()
+    val borders = colGrid.last().map { it.borders - Border.BOTTOM }
+
+    // Limit for number of rows in dataframes inside frame columns
+    val nestedRowsLimit = configuration.nestedRowsLimit
+    val rowsLimit = configuration.rowsLimit
+
+    // Adds the given tag to the html, with the given attributes and contents
+    fun StringBuilder.emitTag(tag: String, attributes: String = "", tagContents: StringBuilder.() -> Unit) {
+        append("<$tag")
+        if (attributes.isNotEmpty()) {
+            append(" ")
+            append(attributes)
+        }
+        append(">")
+        tagContents()
+        append("</$tag>")
+    }
+
+    // Adds a header to the html. This header contains all the column names including nested ones
+    // properly laid out with borders.
+    fun StringBuilder.emitHeader() =
+        emitTag("thead") {
+            for (row in colGrid) {
+                emitTag("tr") {
+                    for ((j, col) in row.withIndex()) {
+                        val colBorders = col.borders.toMutableSet()
+                        // check if the next cell has a left border, and if so, add a right border to this cell
+                        if (row.getOrNull(j + 1)?.borders?.contains(Border.LEFT) == true) {
+                            colBorders += Border.RIGHT
+                        }
+                        emitTag("th", "${colBorders.toClass()} style=\"text-align:left\"") {
+                            append(col.columnWithPath?.name ?: "")
+                        }
+                    }
+                }
+            }
+        }
+
+    // Adds a single cell to the html. DataRows from column groups already need to be split up into separate cells.
+    fun StringBuilder.emitCell(
+        cellValue: Any?,
+        row: AnyRow,
+        col: ColumnWithPath<*>,
+        borders: Set<Border>,
+    ): Unit =
+        emitTag("td", "${borders.toClass()} style=\"vertical-align:top\"") {
+            when (col) {
+                // uses the <details> and <summary> to create a collapsible cell for dataframes
+                is FrameColumn<*> -> {
+                    cellValue as AnyFrame
+                    emitTag("details", if (openNestedDfs) "open" else "") {
+                        emitTag("summary") {
+                            append("DataFrame [${cellValue.size}]")
+                        }
+
+                        // nestedRowsLimit becomes the rowsLimit for nested DFs
+                        // while the new nested rows limit is halved, keeping at least 1
+                        val newRowsLimit = nestedRowsLimit
+                        val newNestedRowsLimit = nestedRowsLimit?.let { ceil(it / 2.0).toInt() }
+
+                        // add the dataframe as a nested table limiting the number of rows if needed
+                        // CSS will not be included here, as it is already included in the main table
+                        cellValue.toStaticHtml(
+                            configuration = configuration.copy(
+                                rowsLimit = newRowsLimit,
+                                nestedRowsLimit = newNestedRowsLimit,
+                            ),
+                            cellRenderer = cellRenderer,
+                            includeCss = false,
+                            openNestedDfs = openNestedDfs,
+                        ).let { append(it.body) }
+
+                        val size = cellValue.rowsCount()
+                        if (size > newRowsLimit ?: Int.MAX_VALUE) {
+                            emitTag("p") {
+                                append("... showing only top $newRowsLimit of $size rows")
+                            }
+                        }
+                    }
+                }
+
+                // Else use the default cell renderer
+                else ->
+                    append(cellRenderer.content(cellValue, configuration).truncatedContent)
+            }
+        }
+
+    // Adds a single row to the html. This row uses the flattened columns to get them displayed non-collapsed.
+    fun StringBuilder.emitRow(row: AnyRow) =
+        emitTag("tr") {
+            for ((i, col) in flattenedCols.withIndex()) {
+                val border = borders[i].toMutableSet()
+                // check if the next cell has a left border, and if so, add a right border to this cell
+                if (borders.getOrNull(i + 1)?.contains(Border.LEFT) == true) {
+                    border += Border.RIGHT
+                }
+                val cell = row[col.path()]
+                emitCell(cell, row, col, border)
+            }
+        }
+
+    // Adds the body of the html. This body contains all the cols and rows of the dataframe.
+    fun StringBuilder.emitBody() =
+        emitTag("tbody") {
+            val rowsCountToRender = minOf(rowsCount(), rowsLimit ?: Int.MAX_VALUE)
+            for (rowIndex in 0..<rowsCountToRender) {
+                emitRow(df[rowIndex])
+            }
+        }
+
+    // Base function which adds the table to the html.
+    fun StringBuilder.emitTable() =
+        emitTag("table", """class="dataframe" id="$id"""") {
+            emitHeader()
+            emitBody()
+        }
+
+    return DataFrameHtmlData(
+        body = buildString { emitTable() },
+        // will hide the table if JS is enabled
+        script =
+            """
+            document.getElementById("$id").style.display = "none";
+            """.trimIndent(),
+    ) + DataFrameHtmlData.tableDefinitions(includeJs = false, includeCss = includeCss)
+}
+
+/**
+ * Border enum used for static rendering of tables in html/css.
+ * @see toClass
+ */
+private enum class Border(val className: String) {
+    // NOTE: these don't render unless at leftmost; add rightBorder to the previous cell.
+    LEFT("leftBorder"),
+    RIGHT("rightBorder"),
+    BOTTOM("bottomBorder"),
+}
+
+/**
+ * Converts a set of borders to a class string for html/css rendering.
+ */
+private fun Set<Border>.toClass(): String =
+    if (isEmpty()) {
+        ""
+    } else {
+        "class=\"${joinToString(" ") { it.className }}\""
+    }
+
+/**
+ * Wrapper class which contains a nullable [ColumnWithPath] and a set of [Border]s.
+ * (Empty cells can have borders too)
+ */
+private data class ColumnWithPathWithBorder<T>(
+    val columnWithPath: ColumnWithPath<T>? = null,
+    val borders: Set<Border> = emptySet(),
+)
+
+/** Returns the depth of the most-nested column in this df/group, starting at 0 */
+internal fun AnyFrame.maxDepth(startingAt: Int = 0): Int =
+    columns().maxOfOrNull {
+        if (it is ColumnGroup<*>) {
+            it.maxDepth(startingAt + 1)
+        } else {
+            startingAt
+        }
+    } ?: startingAt
+
+/** Returns the max number of columns needed to display this column flattened */
+internal fun BaseColumn<*>.maxWidth(): Int =
+    if (this is ColumnGroup<*>) {
+        columns().sumOf { it.maxWidth() }.coerceAtLeast(1)
+    } else {
+        1
+    }
+
+/**
+ * Given a [DataFrame], this function returns a depth-first "matrix" containing all columns
+ * laid out in such a way that they can be used to render the header of a table. The
+ * [ColumnWithPathWithBorder.columnWithPath] is `null` when nothing should be rendered in that cell.
+ * Borders are included too, also for `null` cells.
+ *
+ * For example:
+ * ```
+ * `colGroup` `    |` `|colD` `colC`
+ * `colA    ` `colB|` `|    ` `    `
+ *  ----       ----   ----    ----
+ * ```
+ */
+private fun AnyFrame.getColumnsHeaderGrid(): List<List<ColumnWithPathWithBorder<*>>> {
+    val colGroup = asColumnGroup()
+    val maxDepth = maxDepth()
+    val maxWidth = colGroup.maxWidth()
+    val matrix =
+        MutableList(maxDepth + 1) { depth ->
+            MutableList(maxWidth) {
+                // already adding bottom borders for the last row
+                val borders = if (depth == maxDepth) setOf(Border.BOTTOM) else emptySet()
+                ColumnWithPathWithBorder<Any?>(borders = borders)
+            }
+        }
+
+    fun ColumnWithPath<*>.addChildren(depth: Int = 0, breadth: Int = 0) {
+        var breadth = breadth
+        val children = cols()
+        val lastIndex = children.lastIndex
+        for ((i, child) in cols().withIndex()) {
+            matrix[depth][breadth] = matrix[depth][breadth].copy(columnWithPath = child)
+
+            // draw colGroup side borders unless at start/end of table
+            val borders = mutableSetOf<Border>()
+            if (i == 0 && breadth != 0) borders += Border.LEFT
+            if (i == lastIndex && breadth != maxWidth - 1) borders += Border.RIGHT
+
+            if (borders.isNotEmpty()) {
+                // draw borders in other cells
+                // from depth - 1 (to include not just the children but the current cell too)
+                for (j in (depth - 1).coerceAtLeast(0)..maxDepth) {
+                    matrix[j][breadth] = matrix[j][breadth].let { it.copy(borders = it.borders + borders) }
+                }
+            }
+
+            // recurse if needed to render children of the current column group
+            if (child is ColumnGroup<*>) {
+                child.addChildren(depth + 1, breadth)
+            }
+            breadth += child.maxWidth()
+        }
+    }
+    colGroup.addPath().addChildren()
+    return matrix
+}
+
+internal fun DataFrameHtmlData.print() = println(this)
+
+/**
+ * @return DataFrameHtmlData with table script and css definitions. Can be saved as an *.html file and displayed in the browser
+ */
+public fun <T> DataFrame<T>.toStandaloneHTML(
+    configuration: DisplayConfiguration = DisplayConfiguration.DEFAULT,
+    cellRenderer: CellRenderer = DefaultCellRenderer,
+    getFooter: (DataFrame<T>) -> String? = { "DataFrame [${it.size}]" },
+): DataFrameHtmlData = toHTML(configuration, cellRenderer, getFooter).withTableDefinitions()
+
+/**
+ * @return DataFrameHtmlData without additional definitions. Can be rendered in Jupyter kernel environments
+ */
+public fun <T> DataFrame<T>.toHTML(
+    configuration: DisplayConfiguration = DisplayConfiguration.DEFAULT,
+    cellRenderer: CellRenderer = DefaultCellRenderer,
+    getFooter: (DataFrame<T>) -> String? = { "DataFrame [${it.size}]" },
+): DataFrameHtmlData {
+    val limit = configuration.rowsLimit ?: Int.MAX_VALUE
+
+    val footer = getFooter(this)
+    val bodyFooter = footer?.let {
+        buildString {
+            val openPTag = "<p class=\"dataframe_description\">"
+            if (limit < nrow) {
+                append(openPTag)
+                append("... showing only top $limit of $nrow rows</p>")
+            }
+            append(openPTag)
+            append(footer)
+            append("</p>")
+        }
+    }
+
+    var tableHtml = toHtmlData(configuration, cellRenderer)
+
+    if (configuration.enableFallbackStaticTables) {
+        tableHtml += toStaticHtml(configuration, DefaultCellRenderer)
+    }
+
+    if (bodyFooter != null) {
+        tableHtml += DataFrameHtmlData("", bodyFooter, "")
+    }
+
+    return tableHtml
+}
+
+/**
+ * Container for HTML page data in form of String
+ * Can be used to compose rendered dataframe tables with additional HTML elements
+ */
+public data class DataFrameHtmlData(
+    @Language("css") val style: String = "",
+    @Language("html", prefix = "<body>", suffix = "</body>") val body: String = "",
+    @Language("js") val script: String = "",
+) {
+    override fun toString(): String =
+        buildString {
+            appendLine("<html>")
+            if (style.isNotBlank()) {
+                appendLine("<head>")
+                appendLine("<style type=\"text/css\">")
+                appendLine(style)
+                appendLine("</style>")
+                appendLine("</head>")
+            }
+            if (body.isNotBlank()) {
+                appendLine("<body>")
+                appendLine(body)
+                appendLine("</body>")
+            }
+            if (script.isNotBlank()) {
+                appendLine("<script>")
+                appendLine(script)
+                appendLine("</script>")
+            }
+            appendLine("</html>")
+        }
+
+    public operator fun plus(other: DataFrameHtmlData): DataFrameHtmlData =
+        DataFrameHtmlData(
+            style = when {
+                style.isBlank() -> other.style
+                other.style.isBlank() -> style
+                else -> style + "\n" + other.style
+            },
+            body = when {
+                body.isBlank() -> other.body
+                other.body.isBlank() -> body
+                else -> body + "\n" + other.body
+            },
+            script = when {
+                script.isBlank() -> other.script
+                other.script.isBlank() -> script
+                else -> script + "\n" + other.script
+            },
+        )
+
+    public fun writeHTML(destination: File) {
+        destination.writeText(toString())
+    }
+
+    public fun writeHTML(destination: Path) {
+        destination.writeText(toString())
+    }
+
+    public fun openInBrowser() {
+        val file = File.createTempFile("df_rendering", ".html")
+        writeHTML(file)
+        val uri = file.toURI()
+        val desktop = Desktop.getDesktop()
+        desktop.browse(uri)
+    }
+
+    public fun withTableDefinitions(): DataFrameHtmlData = tableDefinitions() + this
+
+    public companion object {
+        /**
+         * @return CSS and JS required to render DataFrame tables
+         * Can be used as a starting point to create page with multiple tables
+         * @see DataFrame.toHTML
+         * @see DataFrameHtmlData.plus
+         */
+        public fun tableDefinitions(includeJs: Boolean = true, includeCss: Boolean = true): DataFrameHtmlData =
+            DataFrameHtmlData(
+                style = if (includeCss) getResources("/table.css") else "",
+                script = if (includeJs) getResourceText("/init.js") else "",
+                body = "",
+            )
+    }
+}
+
+/**
+ * @param rowsLimit null to disable rows limit
+ * @param cellContentLimit -1 to disable content trimming
+ * @param enableFallbackStaticTables true to add additional pure HTML table that will be visible only if JS  is disabled;
+ * For example hosting *.ipynb files with outputs on GitHub
+ */
+public data class DisplayConfiguration(
+    var rowsLimit: Int? = 20,
+    var nestedRowsLimit: Int? = 5,
+    var cellContentLimit: Int = 40,
+    var cellFormatter: RowColFormatter<*, *>? = null,
+    var decimalFormat: RendererDecimalFormat = RendererDecimalFormat.DEFAULT,
+    var isolatedOutputs: Boolean = flagFromEnv("LETS_PLOT_HTML_ISOLATED_FRAME"),
+    internal val localTesting: Boolean = flagFromEnv("KOTLIN_DATAFRAME_LOCAL_TESTING"),
+    var useDarkColorScheme: Boolean = false,
+    var enableFallbackStaticTables: Boolean = true,
+    var downsizeBufferedImage: Boolean = true,
+) {
+    public companion object {
+        public val DEFAULT: DisplayConfiguration = DisplayConfiguration()
+    }
+
+    /** DSL accessor. */
+    public operator fun invoke(block: DisplayConfiguration.() -> Unit): DisplayConfiguration = apply(block)
+}
+
+@JvmInline
+public value class RendererDecimalFormat private constructor(internal val format: String) {
+    public companion object {
+        public fun fromPrecision(precision: Int): RendererDecimalFormat {
+            require(precision >= 0) { "precision must be >= 0. for custom format use RendererDecimalFormat.of" }
+            return RendererDecimalFormat("%.${precision}f")
+        }
+
+        public fun of(format: String): RendererDecimalFormat = RendererDecimalFormat(format)
+
+        internal val DEFAULT: RendererDecimalFormat = fromPrecision(DEFAULT_PRECISION)
+    }
+}
+
+internal const val DEFAULT_PRECISION = 6
+
+private fun flagFromEnv(envName: String): Boolean = System.getenv(envName)?.toBooleanStrictOrNull() ?: false
+
+internal fun String.escapeNewLines() = replace("\n", "\\n").replace("\r", "\\r")
+
+internal fun String.escapeForHtmlInJs() = replace("\"", "\\\"").escapeNewLines()
+
+internal fun renderValueForHtml(value: Any?, truncate: Int, format: RendererDecimalFormat): RenderedContent =
+    formatter.truncate(renderValueToString(value, format), truncate)
+
+internal fun String.escapeHTML(): String {
+    val str = this
+    return buildString {
+        for (c in str) {
+            if (c.code > 127 || c == '"' || c == '\'' || c == '<' || c == '>' || c == '&' || c == '\\') {
+                append("&#")
+                append(c.code)
+                append(';')
+            } else {
+                append(c)
+            }
+        }
+    }
+}
+
+internal class DataFrameFormatter(
+    val formattedClass: String,
+    val nullClass: String,
+    val structuralClass: String,
+    val numberClass: String,
+    val dataFrameClass: String,
+) {
+
+    private fun wrap(prefix: String, content: RenderedContent, postfix: String): RenderedContent =
+        content.copy(truncatedContent = prefix + content.truncatedContent + postfix)
+
+    private fun String.addCss(css: String? = null): RenderedContent = RenderedContent.text(this).addCss(css)
+
+    private fun String.ellipsis(fullText: String) = addCss(structuralClass).copy(fullContent = fullText)
+
+    private fun String.structural() = addCss(structuralClass)
+
+    private fun RenderedContent.addCss(css: String? = null): RenderedContent =
+        if (css != null) {
+            copy(truncatedContent = "<span class=\"$css\">$truncatedContent</span>", isFormatted = true)
+        } else {
+            this
+        }
+
+    internal fun truncate(str: String, limit: Int): RenderedContent =
+        if (limit in 1 until str.length) {
+            val ellipsis = "...".ellipsis(str)
+            if (limit < 4) {
+                ellipsis
+            } else {
+                val len = (limit - 3).coerceAtLeast(1)
+                RenderedContent.textWithLength(str.substring(0, len).escapeHTML(), len) + ellipsis
+            }
+        } else {
+            RenderedContent.textWithLength(str.escapeHTML(), str.length)
+        }
+
+    fun format(value: Any?, renderer: CellRenderer, configuration: DisplayConfiguration): String {
+        val result = render(value, renderer, configuration)
+        return when {
+            result == null -> ""
+
+            result.isFormatted || result.isTruncated -> {
+                val tooltip = result.fullContent?.escapeHTML() ?: ""
+                return "<span class=\"$formattedClass\" title=\"$tooltip\">${result.truncatedContent}</span>"
+            }
+
+            else -> result.truncatedContent
+        }
+    }
+
+    private class Builder {
+
+        private val sb = StringBuilder()
+
+        private var isFormatted: Boolean = false
+
+        var len: Int = 0
+            private set
+
+        var isTruncated: Boolean = false
+
+        operator fun plusAssign(content: RenderedContent?) {
+            if (content == null) return
+            sb.append(content.truncatedContent)
+            len += content.textLength
+            if (content.isTruncated) isTruncated = true
+            if (content.isFormatted) isFormatted = true
+        }
+
+        fun result() = RenderedContent(sb.toString(), len, if (isTruncated) "" else null, isFormatted)
+    }
+
+    private fun render(value: Any?, renderer: CellRenderer, configuration: DisplayConfiguration): RenderedContent? {
+        val limit = configuration.cellContentLimit
+
+        fun renderList(values: List<*>, prefix: String, postfix: String): RenderedContent {
+            val sb = Builder()
+            sb += prefix.addCss(structuralClass)
+            for (index in values.indices) {
+                if (index > 0) {
+                    sb += ", ".addCss(structuralClass)
+                }
+
+                fun addEllipsis() {
+                    if (limit == sb.len + "..".length + postfix.length) {
+                        sb += "..".addCss(structuralClass)
+                    } else {
+                        sb += "...".addCss(structuralClass)
+                    }
+                    sb.isTruncated = true
+                }
+
+                if (index < values.size - 1 && limit <= sb.len + "...".length + postfix.length) {
+                    addEllipsis()
+                    break
+                }
+                val valueLimit = when (index) {
+                    values.size - 1 -> limit - sb.len - postfix.length
+
+                    // last
+                    values.size - 2 -> { // prev before last
+                        val sizeOfLast = render(
+                            values.last(),
+                            renderer,
+                            configuration.copy(cellContentLimit = 4),
+                        )?.textLength ?: 3
+                        limit - sb.len - ", ".length - sizeOfLast - postfix.length
+                    }
+
+                    else -> limit - sb.len - ", ...".length - postfix.length
+                }
+
+                val rendered = render(values[index], renderer, configuration.copy(cellContentLimit = valueLimit))
+                if (rendered == null || (rendered.textLength == 3 && rendered.isTruncated)) {
+                    addEllipsis()
+                    break
+                }
+                sb += rendered
+            }
+            sb += postfix.addCss(structuralClass)
+            return sb.result()
+        }
+
+        val result = when (value) {
+            null -> "null".addCss(nullClass)
+
+            is AnyRow -> {
+                val values = value.getVisibleValues()
+                when {
+                    values.isEmpty() -> "{ }".addCss(nullClass)
+
+                    else -> {
+                        when (limit) {
+                            3 -> "...".structural()
+                            4 -> "{..}".structural()
+                            5 -> "{...}".structural()
+                            6 -> "{ ...}".structural()
+                            7 -> "{ ... }".structural()
+                            else -> renderList(values, "{ ", " }")
+                        }.let {
+                            it.copy(fullContent = values.joinToString("\n") { it.first + ": " + it.second })
+                        }
+                    }
+                }
+            }
+
+            is AnyFrame -> renderer.content("DataFrame [${value.size}]", configuration).addCss(dataFrameClass)
+
+            is List<*> ->
+                when {
+                    value.isEmpty() -> "[ ]".addCss(nullClass)
+
+                    else -> renderList(value, "[", "]").let {
+                        it.copy(fullContent = value.joinToString("\n") { it.toString() })
+                    }
+                }
+
+            is Pair<*, *> -> {
+                val key = value.first.toString() + ": "
+                val shortValue =
+                    render(value.second, renderer, configuration.copy(cellContentLimit = 3))
+                        ?: "...".addCss(structuralClass)
+                val sizeOfValue = shortValue.textLength
+                val keyLimit = limit - sizeOfValue
+                if (key.length > keyLimit) {
+                    if (limit > 3) {
+                        ("$key...").truncate(limit).addCss(structuralClass)
+                    } else {
+                        null
+                    }
+                } else {
+                    val renderedValue =
+                        render(value.second, renderer, configuration.copy(cellContentLimit = limit - key.length))
+                            ?: "...".addCss(structuralClass)
+                    key.addCss(structuralClass) + renderedValue
+                }
+            }
+
+            is Number -> renderer.content(value, configuration).addCss(numberClass)
+
+            is URL -> wrap(
+                "<a href='$value' target='_blank'>",
+                renderer.content(value.toString(), configuration),
+                "</a>",
+            )
+
+            is DataFrameHtmlData -> RenderedContent.text(value.body)
+
+            else -> renderer.content(value, configuration)
+        }
+        if (result != null && result.textLength > configuration.cellContentLimit) return null
+        return result
+    }
+}
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/io/json.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/io/json.kt
new file mode 100644
index 000000000..ccb73d6e2
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/io/json.kt
@@ -0,0 +1,393 @@
+package org.jetbrains.kotlinx.dataframe.io
+
+import kotlinx.serialization.ExperimentalSerializationApi
+import kotlinx.serialization.json.Json
+import kotlinx.serialization.json.JsonElement
+import kotlinx.serialization.json.decodeFromStream
+import org.intellij.lang.annotations.Language
+import org.jetbrains.kotlinx.dataframe.AnyFrame
+import org.jetbrains.kotlinx.dataframe.AnyRow
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.DataRow
+import org.jetbrains.kotlinx.dataframe.annotations.Interpretable
+import org.jetbrains.kotlinx.dataframe.annotations.OptInRefine
+import org.jetbrains.kotlinx.dataframe.annotations.Refine
+import org.jetbrains.kotlinx.dataframe.api.JsonPath
+import org.jetbrains.kotlinx.dataframe.api.KeyValueProperty
+import org.jetbrains.kotlinx.dataframe.api.single
+import org.jetbrains.kotlinx.dataframe.codeGen.DefaultReadDfMethod
+import org.jetbrains.kotlinx.dataframe.codeGen.DefaultReadJsonMethod
+import org.jetbrains.kotlinx.dataframe.columns.ColumnGroup
+import org.jetbrains.kotlinx.dataframe.columns.FrameColumn
+import org.jetbrains.kotlinx.dataframe.impl.io.encodeDataFrameWithMetadata
+import org.jetbrains.kotlinx.dataframe.impl.io.encodeFrame
+import org.jetbrains.kotlinx.dataframe.impl.io.encodeRow
+import org.jetbrains.kotlinx.dataframe.impl.io.readJson
+import org.jetbrains.kotlinx.dataframe.io.JSON.TypeClashTactic
+import org.jetbrains.kotlinx.dataframe.io.JSON.TypeClashTactic.ANY_COLUMNS
+import org.jetbrains.kotlinx.dataframe.io.JSON.TypeClashTactic.ARRAY_AND_VALUE_COLUMNS
+import java.io.File
+import java.io.InputStream
+import java.net.URL
+import kotlin.reflect.typeOf
+
+public class JSON(
+    private val typeClashTactic: TypeClashTactic = ARRAY_AND_VALUE_COLUMNS,
+    private val keyValuePaths: List<JsonPath> = emptyList(),
+) : SupportedDataFrameFormat {
+    override fun readDataFrame(stream: InputStream, header: List<String>): AnyFrame =
+        DataFrame.readJson(
+            stream = stream,
+            header = header,
+            typeClashTactic = typeClashTactic,
+            keyValuePaths = keyValuePaths,
+        )
+
+    override fun readDataFrame(file: File, header: List<String>): AnyFrame =
+        DataFrame.readJson(
+            file = file,
+            header = header,
+            typeClashTactic = typeClashTactic,
+            keyValuePaths = keyValuePaths,
+        )
+
+    override fun acceptsExtension(ext: String): Boolean = ext == "json"
+
+    override fun acceptsSample(sample: SupportedFormatSample): Boolean = true // Extension is enough
+
+    override val testOrder: Int = 10_000
+
+    override fun createDefaultReadMethod(pathRepresentation: String?): DefaultReadDfMethod =
+        DefaultReadJsonMethod(
+            path = pathRepresentation,
+            arguments = MethodArguments()
+                .add(
+                    "keyValuePaths",
+                    typeOf<List<JsonPath>>(),
+                    "listOf(${
+                        keyValuePaths.joinToString {
+                            "org.jetbrains.kotlinx.dataframe.api.JsonPath(\"\"\"${it.path}\"\"\")"
+                        }
+                    })",
+                )
+                .add(
+                    "typeClashTactic",
+                    typeOf<TypeClashTactic>(),
+                    "org.jetbrains.kotlinx.dataframe.io.JSON.TypeClashTactic.${typeClashTactic.name}",
+                ),
+        )
+
+    /**
+     * Allows the choice of how to handle type clashes when reading a JSON file.
+     * Such as:
+     * ```json
+     * [
+     *     { "a": "text" },
+     *     { "a": { "b": 2 } },
+     *     { "a": [6, 7, 8] }
+     *  ]
+     * ```
+     *
+     * [ARRAY_AND_VALUE_COLUMNS] (default) will create a [DataFrame] looking like (including `null` and `[]` values):
+     * ```
+     * ⌌----------------------------------------------⌍
+     * |  | a:{b:Int?, value:String?, array:List<Int>}|
+     * |--|-------------------------------------------|
+     * | 0|         { b:null, value:"text", array:[] }|
+     * | 1|              { b:2, value:null, array:[] }|
+     * | 2|    { b:null, value:null, array:[6, 7, 8] }|
+     * ⌎----------------------------------------------⌏
+     * ```
+     * So, for the type clashing argument it will create a [ColumnGroup] with the properties `value`, `array`,
+     * and the unwrapped properties of the objects the property can be.
+     *
+     * [ANY_COLUMNS] will create a [DataFrame] looking like:
+     * ```
+     * ⌌-------------⌍
+     * |  |     a:Any|
+     * |--|----------|
+     * | 0|    "text"|
+     * | 1|   { b:2 }|
+     * | 2| [6, 7, 8]|
+     * ⌎-------------⌏
+     * ```
+     */
+    public enum class TypeClashTactic {
+        ARRAY_AND_VALUE_COLUMNS,
+        ANY_COLUMNS,
+    }
+}
+
+internal const val ARRAY_COLUMN_NAME: String = "array"
+internal const val VALUE_COLUMN_NAME: String = "value"
+
+/**
+ * @param file Where to fetch the Json as [InputStream] to be converted to a [DataFrame].
+ * @param keyValuePaths List of [JsonPath]s where instead of a [ColumnGroup], a [FrameColumn]<[KeyValueProperty]>
+ *     will be created.
+ * @param typeClashTactic How to handle type clashes when reading a JSON file.
+ * @param header Optional list of column names. If given, the file will be read like an object with [header] being the keys.
+ * @return [DataFrame] from the given [file].
+ */
+public fun DataFrame.Companion.readJson(
+    file: File,
+    header: List<String> = emptyList(),
+    keyValuePaths: List<JsonPath> = emptyList(),
+    typeClashTactic: TypeClashTactic = ARRAY_AND_VALUE_COLUMNS,
+): AnyFrame = readJson(file.toURI().toURL(), header, keyValuePaths, typeClashTactic)
+
+/**
+ * @param file Where to fetch the Json as [InputStream] to be converted to a [DataRow].
+ * @param keyValuePaths List of [JsonPath]s where instead of a [ColumnGroup], a [FrameColumn]<[KeyValueProperty]>
+ *     will be created.
+ * @param typeClashTactic How to handle type clashes when reading a JSON file.
+ * @param header Optional list of column names. If given, the file will be read like an object with [header] being the keys.
+ * @return [DataRow] from the given [file].
+ */
+public fun DataRow.Companion.readJson(
+    file: File,
+    header: List<String> = emptyList(),
+    keyValuePaths: List<JsonPath> = emptyList(),
+    typeClashTactic: TypeClashTactic = ARRAY_AND_VALUE_COLUMNS,
+): AnyRow = DataFrame.readJson(file, header, keyValuePaths, typeClashTactic).single()
+
+/**
+ * @param path URL or file path from where to fetch the Json as [InputStream] to be converted to a [DataFrame].
+ * @param keyValuePaths List of [JsonPath]s where instead of a [ColumnGroup], a [FrameColumn]<[KeyValueProperty]>
+ *     will be created.
+ * @param typeClashTactic How to handle type clashes when reading a JSON file.
+ * @param header Optional list of column names. If given, the stream will be read like an object with [header] being the keys.
+ * @return [DataFrame] from the given [path].
+ */
+@OptInRefine
+@Interpretable("ReadJson0")
+public fun DataFrame.Companion.readJson(
+    path: String,
+    header: List<String> = emptyList(),
+    keyValuePaths: List<JsonPath> = emptyList(),
+    typeClashTactic: TypeClashTactic = ARRAY_AND_VALUE_COLUMNS,
+): AnyFrame = readJson(asURL(path), header, keyValuePaths, typeClashTactic)
+
+/**
+ * @param path URL or file path from where to fetch the Json as [InputStream] to be converted to a [DataRow].
+ * @param keyValuePaths List of [JsonPath]s where instead of a [ColumnGroup], a [FrameColumn]<[KeyValueProperty]>
+ *     will be created.
+ * @param typeClashTactic How to handle type clashes when reading a JSON file.
+ * @param header Optional list of column names. If given, the stream will be read like an object with [header] being the keys.
+ * @return [DataRow] from the given [path].
+ */
+public fun DataRow.Companion.readJson(
+    path: String,
+    header: List<String> = emptyList(),
+    keyValuePaths: List<JsonPath> = emptyList(),
+    typeClashTactic: TypeClashTactic = ARRAY_AND_VALUE_COLUMNS,
+): AnyRow = DataFrame.readJson(path, header, keyValuePaths, typeClashTactic).single()
+
+/**
+ * @param url Where to fetch the Json as [InputStream] to be converted to a [DataFrame].
+ * @param keyValuePaths List of [JsonPath]s where instead of a [ColumnGroup], a [FrameColumn]<[KeyValueProperty]>
+ *     will be created.
+ * @param typeClashTactic How to handle type clashes when reading a JSON file.
+ * @param header Optional list of column names. If given, the stream will be read like an object with [header] being the keys.
+ * @return [DataFrame] from the given [url].
+ */
+public fun DataFrame.Companion.readJson(
+    url: URL,
+    header: List<String> = emptyList(),
+    keyValuePaths: List<JsonPath> = emptyList(),
+    typeClashTactic: TypeClashTactic = ARRAY_AND_VALUE_COLUMNS,
+): AnyFrame = catchHttpResponse(url) { readJson(it, header, keyValuePaths, typeClashTactic) }
+
+/**
+ * @param url Where to fetch the Json as [InputStream] to be converted to a [DataRow].
+ * @param keyValuePaths List of [JsonPath]s where instead of a [ColumnGroup], a [FrameColumn]<[KeyValueProperty]>
+ *     will be created.
+ * @param typeClashTactic How to handle type clashes when reading a JSON file.
+ * @param header Optional list of column names. If given, the stream will be read like an object with [header] being the keys.
+ * @return [DataRow] from the given [url].
+ */
+public fun DataRow.Companion.readJson(
+    url: URL,
+    header: List<String> = emptyList(),
+    keyValuePaths: List<JsonPath> = emptyList(),
+    typeClashTactic: TypeClashTactic = ARRAY_AND_VALUE_COLUMNS,
+): AnyRow = DataFrame.readJson(url, header, keyValuePaths, typeClashTactic).single()
+
+/**
+ * @param stream Json as [InputStream] to be converted to a [DataFrame].
+ * @param keyValuePaths List of [JsonPath]s where instead of a [ColumnGroup], a [FrameColumn]<[KeyValueProperty]>
+ *     will be created.
+ * @param typeClashTactic How to handle type clashes when reading a JSON file.
+ * @param header Optional list of column names. If given, [stream] will be read like an object with [header] being the keys.
+ * @return [DataFrame] from the given [stream].
+ */
+@OptIn(ExperimentalSerializationApi::class)
+public fun DataFrame.Companion.readJson(
+    stream: InputStream,
+    header: List<String> = emptyList(),
+    keyValuePaths: List<JsonPath> = emptyList(),
+    typeClashTactic: TypeClashTactic = ARRAY_AND_VALUE_COLUMNS,
+): AnyFrame = readJson(Json.decodeFromStream<JsonElement>(stream), header, keyValuePaths, typeClashTactic)
+
+/**
+ * @param stream Json as [InputStream] to be converted to a [DataRow].
+ * @param keyValuePaths List of [JsonPath]s where instead of a [ColumnGroup], a [FrameColumn]<[KeyValueProperty]>
+ *     will be created.
+ * @param typeClashTactic How to handle type clashes when reading a JSON file.
+ * @param header Optional list of column names. If given, [stream] will be read like an object with [header] being the keys.
+ * @return [DataRow] from the given [stream].
+ */
+public fun DataRow.Companion.readJson(
+    stream: InputStream,
+    header: List<String> = emptyList(),
+    keyValuePaths: List<JsonPath> = emptyList(),
+    typeClashTactic: TypeClashTactic = ARRAY_AND_VALUE_COLUMNS,
+): AnyRow = DataFrame.readJson(stream, header, keyValuePaths, typeClashTactic).single()
+
+/**
+ * @param text Json as [String] to be converted to a [DataFrame].
+ * @param keyValuePaths List of [JsonPath]s where instead of a [ColumnGroup], a [FrameColumn]<[KeyValueProperty]>
+ *     will be created.
+ * @param typeClashTactic How to handle type clashes when reading a JSON file.
+ * @param header Optional list of column names. If given, [text] will be read like an object with [header] being the keys.
+ * @return [DataFrame] from the given [text].
+ */
+@Refine
+@Interpretable("ReadJsonStr")
+public fun DataFrame.Companion.readJsonStr(
+    @Language("json") text: String,
+    header: List<String> = emptyList(),
+    keyValuePaths: List<JsonPath> = emptyList(),
+    typeClashTactic: TypeClashTactic = ARRAY_AND_VALUE_COLUMNS,
+): AnyFrame = readJson(Json.parseToJsonElement(text), header, keyValuePaths, typeClashTactic)
+
+/**
+ * @param text Json as [String] to be converted to a [DataRow].
+ * @param keyValuePaths List of [JsonPath]s where instead of a [ColumnGroup], a [FrameColumn]<[KeyValueProperty]>
+ *     will be created.
+ * @param typeClashTactic How to handle type clashes when reading a JSON file.
+ * @param header Optional list of column names. If given, [text] will be read like an object with [header] being the keys.
+ * @return [DataRow] from the given [text].
+ */
+public fun DataRow.Companion.readJsonStr(
+    @Language("json") text: String,
+    header: List<String> = emptyList(),
+    keyValuePaths: List<JsonPath> = emptyList(),
+    typeClashTactic: TypeClashTactic = ARRAY_AND_VALUE_COLUMNS,
+): AnyRow = DataFrame.readJsonStr(text, header, keyValuePaths, typeClashTactic).single()
+
+public fun AnyFrame.toJson(prettyPrint: Boolean = false): String {
+    val json = Json {
+        this.prettyPrint = prettyPrint
+        isLenient = true
+        allowSpecialFloatingPointValues = true
+    }
+    return json.encodeToString(JsonElement.serializer(), encodeFrame(this@toJson))
+}
+
+/**
+ * Converts the DataFrame to a JSON string representation with additional metadata about serialized data.
+ * It is heavily used to implement some integration features in Kotlin Notebook IntelliJ IDEA plugin.
+ *
+ * @param rowLimit The maximum number of top-level dataframe rows to include in the output JSON.
+ * @param nestedRowLimit The maximum number of nested frame rows to include in the output JSON.
+ * If null, all rows are included.
+ * Applied for each frame column recursively
+ * @param prettyPrint Specifies whether the output JSON should be formatted with indentation and line breaks.
+ * @param imageEncodingOptions The options for encoding images. The default is null, which indicates that the image is not encoded as Base64.
+ *
+ * @return The DataFrame converted to a JSON string with metadata.
+ */
+public fun AnyFrame.toJsonWithMetadata(
+    rowLimit: Int,
+    nestedRowLimit: Int? = null,
+    prettyPrint: Boolean = false,
+    customEncoders: List<CustomEncoder> = emptyList(),
+): String {
+    val json = Json {
+        this.prettyPrint = prettyPrint
+        isLenient = true
+        allowSpecialFloatingPointValues = true
+    }
+    return json.encodeToString(
+        JsonElement.serializer(),
+        encodeDataFrameWithMetadata(this@toJsonWithMetadata, rowLimit, nestedRowLimit, customEncoders),
+    )
+}
+
+/**
+ * Interface for defining a custom encoder. That applied to the value during dataframe JSON serialization
+ */
+public interface CustomEncoder {
+    /**
+     * Determines whether this encoder can encode the given input.
+     *
+     * @param input The input object to be checked for suitability.
+     * @return `true` if the input can be encoded, otherwise `false`.
+     */
+    public fun canEncode(input: Any?): Boolean
+
+    /**
+     * Encodes the provided input into a JSON element.
+     *
+     * @param input The input object to be encoded.
+     * @return A JsonElement representing the encoded input.
+     */
+    public fun encode(input: Any?): JsonElement
+}
+
+internal const val DEFAULT_IMG_SIZE = 600
+
+/**
+ * Class representing the options for encoding images.
+ *
+ * @property imageSizeLimit The maximum size to which images should be resized. Defaults to the value of DEFAULT_IMG_SIZE.
+ * @property options Bitwise-OR of the [GZIP_ON] and [LIMIT_SIZE_ON] constants. Defaults to [GZIP_ON] or [LIMIT_SIZE_ON].
+ */
+public class Base64ImageEncodingOptions(
+    public val imageSizeLimit: Int = DEFAULT_IMG_SIZE,
+    private val options: Int = GZIP_ON or LIMIT_SIZE_ON,
+) {
+    public val isGzipOn: Boolean
+        get() = options and GZIP_ON == GZIP_ON
+
+    public val isLimitSizeOn: Boolean
+        get() = options and LIMIT_SIZE_ON == LIMIT_SIZE_ON
+
+    public companion object {
+        public const val ALL_OFF: Int = 0
+        public const val GZIP_ON: Int = 1 // 2^0
+        public const val LIMIT_SIZE_ON: Int = 2 // 2^1
+    }
+}
+
+public fun AnyRow.toJson(prettyPrint: Boolean = false): String {
+    val json = Json {
+        this.prettyPrint = prettyPrint
+        isLenient = true
+        allowSpecialFloatingPointValues = true
+    }
+    return json.encodeToString(JsonElement.serializer(), encodeRow(df(), index()))
+}
+
+public fun AnyFrame.writeJson(file: File, prettyPrint: Boolean = false) {
+    file.writeText(toJson(prettyPrint))
+}
+
+public fun AnyFrame.writeJson(path: String, prettyPrint: Boolean = false): Unit = writeJson(File(path), prettyPrint)
+
+public fun AnyFrame.writeJson(writer: Appendable, prettyPrint: Boolean = false) {
+    writer.append(toJson(prettyPrint))
+}
+
+public fun AnyRow.writeJson(file: File, prettyPrint: Boolean = false) {
+    file.writeText(toJson(prettyPrint))
+}
+
+public fun AnyRow.writeJson(path: String, prettyPrint: Boolean = false) {
+    writeJson(File(path), prettyPrint)
+}
+
+public fun AnyRow.writeJson(writer: Appendable, prettyPrint: Boolean = false) {
+    writer.append(toJson(prettyPrint))
+}
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/io/string.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/io/string.kt
new file mode 100644
index 000000000..c1006f54b
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/io/string.kt
@@ -0,0 +1,211 @@
+package org.jetbrains.kotlinx.dataframe.io
+
+import org.jetbrains.kotlinx.dataframe.AnyFrame
+import org.jetbrains.kotlinx.dataframe.AnyRow
+import org.jetbrains.kotlinx.dataframe.api.asNumbers
+import org.jetbrains.kotlinx.dataframe.api.columnsCount
+import org.jetbrains.kotlinx.dataframe.api.isNumber
+import org.jetbrains.kotlinx.dataframe.api.take
+import org.jetbrains.kotlinx.dataframe.api.toColumn
+import org.jetbrains.kotlinx.dataframe.impl.asArrayAsListOrNull
+import org.jetbrains.kotlinx.dataframe.impl.owner
+import org.jetbrains.kotlinx.dataframe.impl.renderType
+import org.jetbrains.kotlinx.dataframe.impl.scale
+import org.jetbrains.kotlinx.dataframe.impl.truncate
+import org.jetbrains.kotlinx.dataframe.index
+import org.jetbrains.kotlinx.dataframe.jupyter.RenderedContent
+import org.jetbrains.kotlinx.dataframe.ncol
+import org.jetbrains.kotlinx.dataframe.nrow
+import org.jetbrains.kotlinx.dataframe.size
+import java.math.BigDecimal
+
+internal fun AnyFrame.renderToString(
+    rowsLimit: Int = 20,
+    valueLimit: Int = 40,
+    borders: Boolean = false,
+    alignLeft: Boolean = false,
+    columnTypes: Boolean = false,
+    title: Boolean = false,
+    rowIndex: Boolean = true,
+): String {
+    val sb = StringBuilder()
+
+    // title
+    if (title) {
+        sb.appendLine("Data Frame [${size()}]")
+        sb.appendLine()
+    }
+
+    // data
+    val rowsCount = rowsLimit.coerceAtMost(nrow)
+    val cols = if (rowIndex) listOf((0 until rowsCount).toColumn()) + columns() else columns()
+    val header = cols.mapIndexed { colIndex, col ->
+        if (columnTypes && (!rowIndex || colIndex > 0)) {
+            "${col.name()}:${renderType(col)}"
+        } else {
+            col.name()
+        }
+    }
+    val values = cols.map {
+        val top = it.take(rowsLimit)
+        val precision = if (top.isNumber()) top.asNumbers().scale() else 0
+        val decimalFormat =
+            if (precision >= 0) RendererDecimalFormat.fromPrecision(precision) else RendererDecimalFormat.of("%e")
+        top.values().map {
+            renderValueForStdout(it, valueLimit, decimalFormat = decimalFormat).truncatedContent
+        }
+    }
+    val columnLengths = values.mapIndexed { col, vals -> (vals + header[col]).map { it.length }.maxOrNull()!! + 1 }
+
+    // top border
+    if (borders) {
+        sb.append("\u230C")
+        for (i in 1 until columnLengths.sum() + columnLengths.size) sb.append('-')
+        sb.append("\u230D")
+        sb.appendLine()
+        sb.append("|")
+    }
+
+    // header
+    for (col in header.indices) {
+        val len = columnLengths[col]
+        val str = header[col]
+        val padded = if (alignLeft) str.padEnd(len) else str.padStart(len)
+        sb.append(padded)
+        if (borders) sb.append("|")
+    }
+    sb.appendLine()
+
+    // header splitter
+    if (borders) {
+        sb.append("|")
+        for (colLength in columnLengths) {
+            for (i in 1..colLength) sb.append('-')
+            sb.append("|")
+        }
+        sb.appendLine()
+    }
+
+    // data
+    for (row in 0 until rowsCount) {
+        if (borders) sb.append("|")
+        for (col in values.indices) {
+            val len = columnLengths[col]
+            val str = values[col][row]
+            val padded = if (alignLeft) str.padEnd(len) else str.padStart(len)
+            sb.append(padded)
+            if (borders) sb.append("|")
+        }
+        sb.appendLine()
+    }
+
+    // footer
+    if (nrow > rowsLimit) {
+        sb.appendLine("...")
+    } else if (borders) {
+        sb.append("\u230E")
+        for (i in 1 until columnLengths.sum() + columnLengths.size) sb.append('-')
+        sb.append("\u230F")
+        sb.appendLine()
+    }
+    return sb.toString()
+}
+
+internal val valueToStringLimitDefault = 1000
+internal val valueToStringLimitForRowAsTable = 50
+
+internal fun AnyRow.getVisibleValues(): List<Pair<String, Any?>> {
+    fun Any?.skip(): Boolean =
+        when (this) {
+            null -> true
+            is List<*> -> this.isEmpty()
+            is AnyRow -> values().all { it.skip() }
+            else -> false
+        }
+    return owner.columns().map { it.name() to it[index] }.filter { !it.second.skip() }
+}
+
+internal fun AnyRow.renderToString(): String {
+    val values = getVisibleValues()
+    if (values.isEmpty()) return "{ }"
+    return values.joinToString(
+        prefix = "{ ",
+        postfix = " }",
+    ) { "${it.first}:${renderValueForStdout(it.second).truncatedContent}" }
+}
+
+internal fun AnyRow.renderToStringTable(forHtml: Boolean = false): String {
+    if (columnsCount() == 0) return ""
+    val pairs = owner.columns().map { it.name() to renderValueForRowTable(it[index], forHtml) }
+    val width = pairs.maxOf { it.first.length + it.second.textLength } + 4
+    return pairs.joinToString("\n") {
+        it.first + " ".repeat(width - it.first.length - it.second.textLength) + it.second.truncatedContent
+    }
+}
+
+internal fun renderCollectionName(value: Collection<*>) =
+    when (value) {
+        is List -> "List"
+        is Map<*, *> -> "Map"
+        is Set -> "Set"
+        else -> value.javaClass.simpleName
+    }
+
+internal fun renderValueForRowTable(value: Any?, forHtml: Boolean): RenderedContent =
+    when (value) {
+        is AnyFrame -> "DataFrame [${value.nrow} x ${value.ncol}]".let {
+            val content = if (value.nrow == 1) it + " " + value[0].toString() else it
+            RenderedContent.textWithLength(content, "DataFrame".length)
+        }
+
+        is AnyRow -> RenderedContent.textWithLength("DataRow $value", "DataRow".length)
+
+        is Collection<*> -> renderCollectionName(value).let { RenderedContent.textWithLength("$it $value", it.length) }
+
+        else -> if (forHtml) {
+            renderValueForHtml(value, valueToStringLimitForRowAsTable, RendererDecimalFormat.DEFAULT)
+        } else {
+            renderValueForStdout(value, valueToStringLimitForRowAsTable)
+        }
+    }
+
+internal fun renderValueForStdout(
+    value: Any?,
+    limit: Int = valueToStringLimitDefault,
+    decimalFormat: RendererDecimalFormat = RendererDecimalFormat.DEFAULT,
+): RenderedContent =
+    renderValueToString(value, decimalFormat)
+        .truncate(limit)
+        .let { it.copy(truncatedContent = it.truncatedContent.escapeNewLines()) }
+
+internal fun renderValueToString(value: Any?, decimalFormat: RendererDecimalFormat): String =
+    when (value) {
+        is AnyFrame -> "[${value.size}]".let { if (value.nrow == 1) it + " " + value[0].toString() else it }
+
+        is Double -> value.format(decimalFormat)
+
+        is Float -> value.format(decimalFormat)
+
+        is BigDecimal -> value.format(decimalFormat)
+
+        is List<*> -> if (value.isEmpty()) "[ ]" else value.toString()
+
+        is Array<*> -> if (value.isEmpty()) "[ ]" else value.toList().toString()
+
+        else ->
+            value?.asArrayAsListOrNull()
+                ?.let { renderValueToString(it, decimalFormat) }
+                ?: value.toString()
+    }
+
+internal fun internallyRenderable(value: Any?): Boolean =
+    when (value) {
+        is AnyFrame, is Double, is List<*>, null, "" -> true
+        else -> false
+    }
+
+internal fun Double.format(decimalFormat: RendererDecimalFormat): String = decimalFormat.format.format(this)
+
+internal fun Float.format(decimalFormat: RendererDecimalFormat): String = decimalFormat.format.format(this)
+
+internal fun BigDecimal.format(decimalFormat: RendererDecimalFormat): String = decimalFormat.format.format(this)
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/io/tsv.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/io/tsv.kt
new file mode 100644
index 000000000..108d2d7e1
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/io/tsv.kt
@@ -0,0 +1,125 @@
+package org.jetbrains.kotlinx.dataframe.io
+
+import org.jetbrains.kotlinx.dataframe.AnyFrame
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.api.ParserOptions
+import org.jetbrains.kotlinx.dataframe.codeGen.DefaultReadDfMethod
+import org.jetbrains.kotlinx.dataframe.codeGen.DefaultReadTsvMethod
+import java.io.File
+import java.io.FileInputStream
+import java.io.InputStream
+import java.net.URL
+import java.nio.charset.Charset
+
+public class TSV : SupportedDataFrameFormat {
+    override fun readDataFrame(stream: InputStream, header: List<String>): AnyFrame =
+        DataFrame.readTSV(stream, header = header)
+
+    override fun readDataFrame(file: File, header: List<String>): AnyFrame = DataFrame.readTSV(file, header = header)
+
+    override fun acceptsExtension(ext: String): Boolean = ext == "tsv"
+
+    override fun acceptsSample(sample: SupportedFormatSample): Boolean = true // Extension is enough
+
+    override val testOrder: Int = 30000
+
+    override fun createDefaultReadMethod(pathRepresentation: String?): DefaultReadDfMethod =
+        DefaultReadTsvMethod(pathRepresentation)
+}
+
+private const val TAB_CHAR = '\t'
+
+public fun DataFrame.Companion.readTSV(
+    fileOrUrl: String,
+    header: List<String> = listOf(),
+    colTypes: Map<String, ColType> = mapOf(),
+    skipLines: Int = 0,
+    readLines: Int? = null,
+    duplicate: Boolean = true,
+    charset: Charset = Charsets.UTF_8,
+    parserOptions: ParserOptions? = null,
+): DataFrame<*> =
+    catchHttpResponse(asURL(fileOrUrl)) {
+        readDelim(
+            it,
+            TAB_CHAR,
+            header,
+            isCompressed(fileOrUrl),
+            CSVType.TDF,
+            colTypes,
+            skipLines,
+            readLines,
+            duplicate,
+            charset,
+            parserOptions,
+        )
+    }
+
+public fun DataFrame.Companion.readTSV(
+    file: File,
+    header: List<String> = listOf(),
+    colTypes: Map<String, ColType> = mapOf(),
+    skipLines: Int = 0,
+    readLines: Int? = null,
+    duplicate: Boolean = true,
+    charset: Charset = Charsets.UTF_8,
+): DataFrame<*> =
+    readDelim(
+        FileInputStream(file),
+        TAB_CHAR,
+        header,
+        isCompressed(file),
+        CSVType.TDF,
+        colTypes,
+        skipLines,
+        readLines,
+        duplicate,
+        charset,
+    )
+
+public fun DataFrame.Companion.readTSV(
+    url: URL,
+    header: List<String> = listOf(),
+    colTypes: Map<String, ColType> = mapOf(),
+    skipLines: Int = 0,
+    readLines: Int? = null,
+    duplicate: Boolean = true,
+    charset: Charset = Charsets.UTF_8,
+    parserOptions: ParserOptions? = null,
+): DataFrame<*> =
+    readTSV(
+        url.openStream(),
+        header,
+        isCompressed(url),
+        colTypes,
+        skipLines,
+        readLines,
+        duplicate,
+        charset,
+        parserOptions,
+    )
+
+public fun DataFrame.Companion.readTSV(
+    stream: InputStream,
+    header: List<String> = listOf(),
+    isCompressed: Boolean = false,
+    colTypes: Map<String, ColType> = mapOf(),
+    skipLines: Int = 0,
+    readLines: Int? = null,
+    duplicate: Boolean = true,
+    charset: Charset = Charsets.UTF_8,
+    parserOptions: ParserOptions? = null,
+): DataFrame<*> =
+    readDelim(
+        stream,
+        TAB_CHAR,
+        header,
+        isCompressed,
+        CSVType.TDF,
+        colTypes,
+        skipLines,
+        readLines,
+        duplicate,
+        charset,
+        parserOptions,
+    )
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/jupyter/CellRenderer.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/jupyter/CellRenderer.kt
new file mode 100644
index 000000000..6046d3f89
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/jupyter/CellRenderer.kt
@@ -0,0 +1,67 @@
+package org.jetbrains.kotlinx.dataframe.jupyter
+
+import org.jetbrains.kotlinx.dataframe.io.DisplayConfiguration
+import org.jetbrains.kotlinx.dataframe.io.renderValueForHtml
+import org.jetbrains.kotlinx.dataframe.io.tooltipLimit
+
+public data class RenderedContent(
+    val truncatedContent: String,
+    val textLength: Int,
+    val fullContent: String?,
+    val isFormatted: Boolean,
+) {
+    public companion object {
+
+        public fun media(html: String): RenderedContent = RenderedContent(html, 0, null, false)
+
+        public fun textWithLength(str: String, len: Int): RenderedContent = RenderedContent(str, len, null, false)
+
+        public fun text(str: String): RenderedContent = RenderedContent(str, str.length, null, false)
+
+        public fun truncatedText(str: String, fullText: String): RenderedContent =
+            RenderedContent(str, str.length, fullText, false)
+    }
+
+    val isTruncated: Boolean
+        get() = fullContent != null
+
+    public operator fun plus(other: RenderedContent): RenderedContent =
+        RenderedContent(
+            truncatedContent = truncatedContent + other.truncatedContent,
+            textLength = textLength + other.textLength,
+            fullContent = fullContent?.plus(other.fullContent) ?: other.fullContent,
+            isFormatted = isFormatted || other.isFormatted,
+        )
+}
+
+public interface CellRenderer {
+    /**
+     * Returns [value] rendered to HTML text, or null if such rendering is impossible
+     */
+    public fun content(value: Any?, configuration: DisplayConfiguration): RenderedContent
+
+    /**
+     * Returns cell tooltip for this [value]
+     */
+    public fun tooltip(value: Any?, configuration: DisplayConfiguration): String
+}
+
+public abstract class ChainedCellRenderer(private val parent: CellRenderer) : CellRenderer {
+    public abstract fun maybeContent(value: Any?, configuration: DisplayConfiguration): RenderedContent?
+
+    public abstract fun maybeTooltip(value: Any?, configuration: DisplayConfiguration): String?
+
+    public override fun content(value: Any?, configuration: DisplayConfiguration): RenderedContent =
+        maybeContent(value, configuration) ?: parent.content(value, configuration)
+
+    public override fun tooltip(value: Any?, configuration: DisplayConfiguration): String =
+        maybeTooltip(value, configuration) ?: parent.tooltip(value, configuration)
+}
+
+public object DefaultCellRenderer : CellRenderer {
+    public override fun content(value: Any?, configuration: DisplayConfiguration): RenderedContent =
+        renderValueForHtml(value, configuration.cellContentLimit, configuration.decimalFormat)
+
+    public override fun tooltip(value: Any?, configuration: DisplayConfiguration): String =
+        renderValueForHtml(value, tooltipLimit, configuration.decimalFormat).truncatedContent
+}
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/jupyter/DisableRowsLimitWrapper.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/jupyter/DisableRowsLimitWrapper.kt
new file mode 100644
index 000000000..68bd3d9ab
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/jupyter/DisableRowsLimitWrapper.kt
@@ -0,0 +1,8 @@
+package org.jetbrains.kotlinx.dataframe.jupyter
+
+import org.jetbrains.kotlinx.dataframe.AnyFrame
+
+/**
+ * Allows for disabling the rows limit when generating a DISPLAY output in Jupyter.
+ */
+public data class DisableRowsLimitWrapper(public val value: AnyFrame)
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/jupyter/JupyterCellRenderer.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/jupyter/JupyterCellRenderer.kt
new file mode 100644
index 000000000..d66aaa5e4
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/jupyter/JupyterCellRenderer.kt
@@ -0,0 +1,25 @@
+package org.jetbrains.kotlinx.dataframe.jupyter
+
+import org.jetbrains.kotlinx.dataframe.io.DisplayConfiguration
+import org.jetbrains.kotlinx.dataframe.io.internallyRenderable
+import org.jetbrains.kotlinx.dataframe.io.renderValueForHtml
+import org.jetbrains.kotlinx.jupyter.api.MimeTypedResult
+import org.jetbrains.kotlinx.jupyter.api.Notebook
+import org.jetbrains.kotlinx.jupyter.api.Renderable
+import org.jetbrains.kotlinx.jupyter.api.libraries.ExecutionHost
+
+internal class JupyterCellRenderer(private val notebook: Notebook, private val host: ExecutionHost) :
+    ChainedCellRenderer(DefaultCellRenderer) {
+    override fun maybeContent(value: Any?, configuration: DisplayConfiguration): RenderedContent? {
+        val renderersProcessor = notebook.renderersProcessor
+        if (internallyRenderable(value)) return null
+        val renderedVal = renderersProcessor.renderValue(host, value)
+        val finalVal = if (renderedVal is Renderable) renderedVal.render(notebook) else renderedVal
+        if (finalVal is MimeTypedResult && "text/html" in finalVal) {
+            return RenderedContent.media(finalVal["text/html"] ?: "")
+        }
+        return renderValueForHtml(finalVal, configuration.cellContentLimit, configuration.decimalFormat)
+    }
+
+    override fun maybeTooltip(value: Any?, configuration: DisplayConfiguration): String? = null
+}
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/jupyter/JupyterConfiguration.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/jupyter/JupyterConfiguration.kt
new file mode 100644
index 000000000..c9fce63c6
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/jupyter/JupyterConfiguration.kt
@@ -0,0 +1,14 @@
+package org.jetbrains.kotlinx.dataframe.jupyter
+
+import org.jetbrains.kotlinx.dataframe.BuildConfig
+import org.jetbrains.kotlinx.dataframe.io.DisplayConfiguration
+
+public class JupyterConfiguration {
+    public val display: DisplayConfiguration = DisplayConfiguration()
+
+    /** Version of the library. */
+    public val version: String = BuildConfig.VERSION
+
+    /** DSL accessor. */
+    public operator fun invoke(block: JupyterConfiguration.() -> Unit): JupyterConfiguration = apply(block)
+}
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/jupyter/JupyterHtmlRenderer.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/jupyter/JupyterHtmlRenderer.kt
new file mode 100644
index 000000000..9dc40c3c6
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/jupyter/JupyterHtmlRenderer.kt
@@ -0,0 +1,142 @@
+package org.jetbrains.kotlinx.dataframe.jupyter
+
+import kotlinx.serialization.ExperimentalSerializationApi
+import kotlinx.serialization.json.addAll
+import kotlinx.serialization.json.buildJsonObject
+import kotlinx.serialization.json.put
+import kotlinx.serialization.json.putJsonArray
+import org.jetbrains.kotlinx.dataframe.api.take
+import org.jetbrains.kotlinx.dataframe.impl.io.BufferedImageEncoder
+import org.jetbrains.kotlinx.dataframe.impl.io.DataframeConvertableEncoder
+import org.jetbrains.kotlinx.dataframe.impl.io.SerializationKeys.COLUMNS
+import org.jetbrains.kotlinx.dataframe.impl.io.SerializationKeys.KOTLIN_DATAFRAME
+import org.jetbrains.kotlinx.dataframe.impl.io.SerializationKeys.NCOL
+import org.jetbrains.kotlinx.dataframe.impl.io.SerializationKeys.NROW
+import org.jetbrains.kotlinx.dataframe.impl.io.encodeFrame
+import org.jetbrains.kotlinx.dataframe.io.Base64ImageEncodingOptions
+import org.jetbrains.kotlinx.dataframe.io.CustomEncoder
+import org.jetbrains.kotlinx.dataframe.io.DataFrameHtmlData
+import org.jetbrains.kotlinx.dataframe.io.DisplayConfiguration
+import org.jetbrains.kotlinx.dataframe.io.toHTML
+import org.jetbrains.kotlinx.dataframe.io.toJsonWithMetadata
+import org.jetbrains.kotlinx.dataframe.io.toStaticHtml
+import org.jetbrains.kotlinx.dataframe.jupyter.KotlinNotebookPluginUtils.convertToDataFrame
+import org.jetbrains.kotlinx.dataframe.nrow
+import org.jetbrains.kotlinx.dataframe.size
+import org.jetbrains.kotlinx.jupyter.api.HtmlData
+import org.jetbrains.kotlinx.jupyter.api.JupyterClientType
+import org.jetbrains.kotlinx.jupyter.api.KotlinKernelVersion
+import org.jetbrains.kotlinx.jupyter.api.MimeTypedResult
+import org.jetbrains.kotlinx.jupyter.api.Notebook
+import org.jetbrains.kotlinx.jupyter.api.libraries.JupyterIntegration
+import org.jetbrains.kotlinx.jupyter.api.mimeResult
+import org.jetbrains.kotlinx.jupyter.api.outputs.isIsolatedHtml
+import org.jetbrains.kotlinx.jupyter.api.renderHtmlAsIFrameIfNeeded
+
+/** Starting from this version, dataframe integration will respond with additional data for rendering in Kotlin Notebooks plugin. */
+private const val MIN_KERNEL_VERSION_FOR_NEW_TABLES_UI = "0.11.0.311"
+private const val MIN_IDE_VERSION_SUPPORT_JSON_WITH_METADATA = 241
+private const val MIN_IDE_VERSION_SUPPORT_IMAGE_VIEWER = 242
+private const val MIN_IDE_VERSION_SUPPORT_DATAFRAME_CONVERTABLE = 243
+
+internal class JupyterHtmlRenderer(val display: DisplayConfiguration, val builder: JupyterIntegration.Builder)
+
+@OptIn(ExperimentalSerializationApi::class)
+internal inline fun <reified T : Any> JupyterHtmlRenderer.render(
+    noinline getFooter: (T) -> String,
+    crossinline modifyConfig: T.(DisplayConfiguration) -> DisplayConfiguration = { it },
+    applyRowsLimit: Boolean = true,
+) = builder.renderWithHost<T> { host, value ->
+    val contextRenderer = JupyterCellRenderer(this.notebook, host)
+    val reifiedDisplayConfiguration = value.modifyConfig(display)
+    val footer = getFooter(value)
+
+    val df = convertToDataFrame(value)
+
+    val limit = if (applyRowsLimit) {
+        reifiedDisplayConfiguration.rowsLimit ?: df.nrow
+    } else {
+        df.nrow
+    }
+
+    val html = DataFrameHtmlData
+        .tableDefinitions(
+            includeJs = reifiedDisplayConfiguration.isolatedOutputs,
+            includeCss = true,
+        ).plus(
+            df.toHTML(
+                // is added later to make sure it's put outside of potential iFrames
+                configuration = reifiedDisplayConfiguration.copy(enableFallbackStaticTables = false),
+                cellRenderer = contextRenderer,
+            ) { footer },
+        ).toJupyterHtmlData()
+
+    // Generates a static version of the table which can be displayed in GitHub previews etc.
+    val staticHtml = df.toStaticHtml(reifiedDisplayConfiguration, DefaultCellRenderer).toJupyterHtmlData()
+
+    if (notebook.kernelVersion >= KotlinKernelVersion.from(MIN_KERNEL_VERSION_FOR_NEW_TABLES_UI)!!) {
+        val ideBuildNumber = KotlinNotebookPluginUtils.getKotlinNotebookIDEBuildNumber()
+
+        // TODO Do we need to handle the improved meta data here as well?
+        val jsonEncodedDf = when {
+            !ideBuildNumber.supportsDynamicNestedTables() -> {
+                buildJsonObject {
+                    put(NROW, df.size.nrow)
+                    put(NCOL, df.size.ncol)
+                    putJsonArray(COLUMNS) { addAll(df.columnNames()) }
+                    put(KOTLIN_DATAFRAME, encodeFrame(df.take(limit)))
+                }.toString()
+            }
+
+            else -> {
+                val encoders = buildList<CustomEncoder> {
+                    if (ideBuildNumber.supportsDataFrameConvertableValues()) {
+                        add(DataframeConvertableEncoder(this))
+                    }
+                    if (ideBuildNumber.supportsImageViewer()) {
+                        add(BufferedImageEncoder(Base64ImageEncodingOptions()))
+                    }
+                }
+
+                df.toJsonWithMetadata(
+                    rowLimit = limit,
+                    nestedRowLimit = reifiedDisplayConfiguration.rowsLimit,
+                    customEncoders = encoders,
+                )
+            }
+        }
+
+        notebook.renderAsIFrameAsNeeded(html, staticHtml, jsonEncodedDf)
+    } else {
+        notebook.renderHtmlAsIFrameIfNeeded(html)
+    }
+}
+
+private fun KotlinNotebookPluginUtils.IdeBuildNumber?.supportsDynamicNestedTables() =
+    this != null && majorVersion >= MIN_IDE_VERSION_SUPPORT_JSON_WITH_METADATA
+
+private fun KotlinNotebookPluginUtils.IdeBuildNumber?.supportsImageViewer() =
+    this != null && majorVersion >= MIN_IDE_VERSION_SUPPORT_IMAGE_VIEWER
+
+private fun KotlinNotebookPluginUtils.IdeBuildNumber?.supportsDataFrameConvertableValues() =
+    this != null && majorVersion >= MIN_IDE_VERSION_SUPPORT_DATAFRAME_CONVERTABLE
+
+internal fun Notebook.renderAsIFrameAsNeeded(
+    data: HtmlData,
+    staticData: HtmlData,
+    jsonEncodedDf: String,
+): MimeTypedResult {
+    val textHtml = if (jupyterClientType == JupyterClientType.KOTLIN_NOTEBOOK) {
+        data.generateIframePlaneText(currentColorScheme) +
+            staticData.toString(currentColorScheme)
+    } else {
+        (data + staticData).toString(currentColorScheme)
+    }
+
+    return mimeResult(
+        "text/html" to textHtml,
+        "application/kotlindataframe+json" to jsonEncodedDf,
+    ).also { it.isIsolatedHtml = false }
+}
+
+internal fun DataFrameHtmlData.toJupyterHtmlData() = HtmlData(style, body, script)
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/jupyter/KotlinNotebookPluginUtils.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/jupyter/KotlinNotebookPluginUtils.kt
new file mode 100644
index 000000000..6799f41ca
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/jupyter/KotlinNotebookPluginUtils.kt
@@ -0,0 +1,300 @@
+package org.jetbrains.kotlinx.dataframe.jupyter
+
+import org.jetbrains.kotlinx.dataframe.AnyCol
+import org.jetbrains.kotlinx.dataframe.AnyFrame
+import org.jetbrains.kotlinx.dataframe.AnyRow
+import org.jetbrains.kotlinx.dataframe.DataRow
+import org.jetbrains.kotlinx.dataframe.api.Convert
+import org.jetbrains.kotlinx.dataframe.api.FormatClause
+import org.jetbrains.kotlinx.dataframe.api.FormattedFrame
+import org.jetbrains.kotlinx.dataframe.api.Gather
+import org.jetbrains.kotlinx.dataframe.api.GroupBy
+import org.jetbrains.kotlinx.dataframe.api.GroupClause
+import org.jetbrains.kotlinx.dataframe.api.InsertClause
+import org.jetbrains.kotlinx.dataframe.api.Merge
+import org.jetbrains.kotlinx.dataframe.api.MoveClause
+import org.jetbrains.kotlinx.dataframe.api.Pivot
+import org.jetbrains.kotlinx.dataframe.api.PivotGroupBy
+import org.jetbrains.kotlinx.dataframe.api.ReducedGroupBy
+import org.jetbrains.kotlinx.dataframe.api.ReducedPivot
+import org.jetbrains.kotlinx.dataframe.api.ReducedPivotGroupBy
+import org.jetbrains.kotlinx.dataframe.api.RenameClause
+import org.jetbrains.kotlinx.dataframe.api.ReplaceClause
+import org.jetbrains.kotlinx.dataframe.api.Split
+import org.jetbrains.kotlinx.dataframe.api.SplitWithTransform
+import org.jetbrains.kotlinx.dataframe.api.Update
+import org.jetbrains.kotlinx.dataframe.api.at
+import org.jetbrains.kotlinx.dataframe.api.dataFrameOf
+import org.jetbrains.kotlinx.dataframe.api.frames
+import org.jetbrains.kotlinx.dataframe.api.getColumn
+import org.jetbrains.kotlinx.dataframe.api.into
+import org.jetbrains.kotlinx.dataframe.api.isComparable
+import org.jetbrains.kotlinx.dataframe.api.sortWith
+import org.jetbrains.kotlinx.dataframe.api.toDataFrame
+import org.jetbrains.kotlinx.dataframe.api.values
+import org.jetbrains.kotlinx.dataframe.columns.ColumnPath
+import org.jetbrains.kotlinx.dataframe.impl.ColumnNameGenerator
+
+/**
+ * A class with utility methods for Kotlin Notebook Plugin integration.
+ * Kotlin Notebook Plugin acts as a client of Kotlin Jupyter kernel and uses this functionality
+ * for dynamic pagination when rendering dataframes.
+ * The plugin sends the following code to the kernel to evaluate:
+ * DISPLAY(KotlinNotebooksPluginUtils.getRowsSubsetForRendering(Out[...], 0, 20), "")
+ */
+public object KotlinNotebookPluginUtils {
+    private const val KTNB_IDE_BUILD_PROP = "KTNB_IDE_BUILD_NUMBER"
+
+    /**
+     * Returns a subset of rows from the given dataframe for rendering.
+     * It's used for example for dynamic pagination in Kotlin Notebook Plugin.
+     */
+    public fun getRowsSubsetForRendering(dataFrameLike: Any?, startIdx: Int, endIdx: Int): DisableRowsLimitWrapper =
+        when (dataFrameLike) {
+            null -> throw IllegalArgumentException("Dataframe is null")
+            else -> getRowsSubsetForRendering(convertToDataFrame(dataFrameLike), startIdx, endIdx)
+        }
+
+    /**
+     * Returns a subset of rows from the given dataframe for rendering.
+     * It's used for example for dynamic pagination in Kotlin Notebook Plugin.
+     */
+    public fun getRowsSubsetForRendering(df: AnyFrame, startIdx: Int, endIdx: Int): DisableRowsLimitWrapper =
+        DisableRowsLimitWrapper(df[startIdx..<endIdx])
+
+    /**
+     * Sorts a dataframe-like object by multiple columns.
+     * If a column type is not comparable, sorting by string representation is applied instead.
+     *
+     * @param dataFrameLike The dataframe-like object to sort.
+     * @param columnPaths The list of columns to sort by. Each element in the list represents a column path
+     * @param desc The list of booleans indicating whether each column should be sorted in descending order.
+     *             The size of this list should be the same as the size of the `columns` list.
+     *
+     * @throws IllegalArgumentException if `dataFrameLike` is `null`.
+     *
+     * @return The sorted dataframe.
+     */
+    public fun sortByColumns(dataFrameLike: Any?, columnPaths: List<List<String>>, desc: List<Boolean>): AnyFrame =
+        when (dataFrameLike) {
+            null -> throw IllegalArgumentException("Dataframe is null")
+            else -> sortByColumns(convertToDataFrame(dataFrameLike), columnPaths, desc)
+        }
+
+    /**
+     * Sorts a dataframe by multiple columns with specified sorting order for each column.
+     * If a column type is not comparable, sorting by string representation is applied instead.
+     *
+     * @param df The dataframe to be sorted.
+     * @param columnPaths A list of column paths where each path is a list of strings representing the hierarchical path of the column.
+     * @param isDesc A list of boolean values indicating whether each column should be sorted in descending order;
+     *               true for descending, false for ascending. The size of this list should match the size of `columnPaths`.
+     * @return The sorted dataframe.
+     */
+    public fun sortByColumns(df: AnyFrame, columnPaths: List<List<String>>, isDesc: List<Boolean>): AnyFrame {
+        require(columnPaths.all { it.isNotEmpty() })
+        require(columnPaths.size == isDesc.size)
+
+        val sortKeys = columnPaths.map { path ->
+            ColumnPath(path)
+        }
+
+        val comparator = createComparator(sortKeys, isDesc)
+
+        return df.sortWith(comparator)
+    }
+
+    private fun createComparator(sortKeys: List<ColumnPath>, isDesc: List<Boolean>): Comparator<DataRow<*>> {
+        return Comparator { row1, row2 ->
+            for ((key, desc) in sortKeys.zip(isDesc)) {
+                val comparisonResult = if (row1.df().getColumn(key).isComparable()) {
+                    compareComparableValues(row1, row2, key, desc)
+                } else {
+                    compareStringValues(row1, row2, key, desc)
+                }
+                // If a comparison result is non-zero, we have resolved the ordering
+                if (comparisonResult != 0) return@Comparator comparisonResult
+            }
+            // All comparisons are equal
+            0
+        }
+    }
+
+    @Suppress("UNCHECKED_CAST")
+    private fun compareComparableValues(
+        row1: DataRow<*>,
+        row2: DataRow<*>,
+        key: ColumnPath,
+        desc: Boolean,
+    ): Int {
+        val firstValue = row1.getValueOrNull(key) as Comparable<Any?>?
+        val secondValue = row2.getValueOrNull(key) as Comparable<Any?>?
+
+        return when {
+            firstValue == null && secondValue == null -> 0
+            firstValue == null -> if (desc) 1 else -1
+            secondValue == null -> if (desc) -1 else 1
+            desc -> secondValue.compareTo(firstValue)
+            else -> firstValue.compareTo(secondValue)
+        }
+    }
+
+    private fun compareStringValues(
+        row1: DataRow<*>,
+        row2: DataRow<*>,
+        key: ColumnPath,
+        desc: Boolean,
+    ): Int {
+        val firstValue = (row1.getValueOrNull(key)?.toString() ?: "")
+        val secondValue = (row2.getValueOrNull(key)?.toString() ?: "")
+
+        return if (desc) {
+            secondValue.compareTo(firstValue)
+        } else {
+            firstValue.compareTo(secondValue)
+        }
+    }
+
+    internal fun isDataframeConvertable(dataframeLike: Any?): Boolean =
+        when (dataframeLike) {
+            is Pivot<*>,
+            is ReducedGroupBy<*, *>,
+            is ReducedPivot<*>,
+            is PivotGroupBy<*>,
+            is ReducedPivotGroupBy<*>,
+            is SplitWithTransform<*, *, *>,
+            is Split<*, *>,
+            is Merge<*, *, *>,
+            is Gather<*, *, *, *>,
+            is Update<*, *>,
+            is Convert<*, *>,
+            is FormattedFrame<*>,
+            is AnyCol,
+            is AnyRow,
+            is GroupBy<*, *>,
+            is AnyFrame,
+            is DisableRowsLimitWrapper,
+            is MoveClause<*, *>,
+            is RenameClause<*, *>,
+            is ReplaceClause<*, *>,
+            is GroupClause<*, *>,
+            is InsertClause<*>,
+            is FormatClause<*, *>,
+            -> true
+
+            else -> false
+        }
+
+    /**
+     * Converts [dataframeLike] to [AnyFrame].
+     * If [dataframeLike] is already [AnyFrame] then it is returned as is.
+     * If it's not possible to convert [dataframeLike] to [AnyFrame] then [IllegalArgumentException] is thrown.
+     */
+    public fun convertToDataFrame(dataframeLike: Any): AnyFrame =
+        when (dataframeLike) {
+            is Pivot<*> -> dataframeLike.frames().toDataFrame()
+
+            is ReducedGroupBy<*, *> -> dataframeLike.values()
+
+            is ReducedPivot<*> -> dataframeLike.values().toDataFrame()
+
+            is PivotGroupBy<*> -> dataframeLike.frames()
+
+            is ReducedPivotGroupBy<*> -> dataframeLike.values()
+
+            is SplitWithTransform<*, *, *> -> dataframeLike.into()
+
+            is Split<*, *> -> dataframeLike.toDataFrame()
+
+            is Merge<*, *, *> -> dataframeLike.into(
+                generateRandomVariationOfColumnName(
+                    "merged",
+                    dataframeLike.df.columnNames(),
+                ),
+            )
+
+            is Gather<*, *, *, *> -> dataframeLike.into(
+                generateRandomVariationOfColumnName("key", dataframeLike.df.columnNames()),
+                generateRandomVariationOfColumnName("value", dataframeLike.df.columnNames()),
+            )
+
+            is Update<*, *> -> dataframeLike.df
+
+            is Convert<*, *> -> dataframeLike.df
+
+            is FormattedFrame<*> -> dataframeLike.df
+
+            is AnyCol -> dataFrameOf(dataframeLike)
+
+            is AnyRow -> dataframeLike.toDataFrame()
+
+            is GroupBy<*, *> -> dataframeLike.toDataFrame()
+
+            is AnyFrame -> dataframeLike
+
+            is DisableRowsLimitWrapper -> dataframeLike.value
+
+            is MoveClause<*, *> -> dataframeLike.df
+
+            is RenameClause<*, *> -> dataframeLike.df
+
+            is ReplaceClause<*, *> -> dataframeLike.df
+
+            is GroupClause<*, *> -> dataframeLike.into(
+                generateRandomVariationOfColumnName(
+                    "untitled",
+                    dataframeLike.df.columnNames(),
+                ),
+            )
+
+            is InsertClause<*> -> dataframeLike.at(0)
+
+            is FormatClause<*, *> -> dataframeLike.df
+
+            else -> throw IllegalArgumentException("Unsupported type: ${dataframeLike::class}")
+        }
+
+    /**
+     * Generates a random variation of a column name that is unique among the provided used names.
+     *
+     * @param preferredName The preferred name for the column.
+     * @param usedNames The list of already used column names.
+     * @return A unique random variation of the preferred name.
+     */
+    public fun generateRandomVariationOfColumnName(
+        preferredName: String,
+        usedNames: List<String> = emptyList(),
+    ): String = ColumnNameGenerator(usedNames).addUnique(preferredName)
+
+    /**
+     * Retrieves the build number of the Kotlin Notebook IDE.
+     *
+     * @return The build number of the Kotlin Notebook IDE as an instance of [IdeBuildNumber],
+     * or null if the build number is not available.
+     */
+    public fun getKotlinNotebookIDEBuildNumber(): IdeBuildNumber? {
+        val value = System.getProperty(KTNB_IDE_BUILD_PROP, null) ?: return null
+        return IdeBuildNumber.fromString(value)
+    }
+
+    public data class IdeBuildNumber(val ideName: String, val majorVersion: Int, val buildId: Int) {
+        public companion object {
+            public fun fromString(buildNumber: String): IdeBuildNumber? {
+                val parts = buildNumber.split(";")
+                return if (parts.size >= 3) constructIdeBuildNumber(parts) else null
+            }
+
+            private fun constructIdeBuildNumber(parts: List<String>): IdeBuildNumber? {
+                val ideName = parts[0]
+                val majorVersion = parts[1].toIntOrNull()
+                val buildId = parts[2].toIntOrNull()
+
+                return if (majorVersion != null && buildId != null) {
+                    IdeBuildNumber(ideName, majorVersion, buildId)
+                } else {
+                    null
+                }
+            }
+        }
+    }
+}
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/jupyter/importDataSchema.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/jupyter/importDataSchema.kt
new file mode 100644
index 000000000..4d236f3e4
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/jupyter/importDataSchema.kt
@@ -0,0 +1,49 @@
+package org.jetbrains.kotlinx.dataframe.jupyter
+
+import org.intellij.lang.annotations.Language
+import java.io.File
+import java.net.URL
+
+public class ImportDataSchema(public val url: URL) {
+    public constructor(path: String) : this(URL(path))
+    public constructor(file: File) : this(file.toURI().toURL())
+}
+
+public fun importDataSchema(url: URL): ImportDataSchema = ImportDataSchema(url)
+
+public fun importDataSchema(path: String): ImportDataSchema = ImportDataSchema(path)
+
+public fun importDataSchema(file: File): ImportDataSchema = ImportDataSchema(file)
+
+@Language("kts")
+internal val importDataSchema =
+    """
+    /** Import the type-only data schema from [url]. */
+    fun importDataSchema(url: URL, name: String) {
+        val formats = listOf(
+            OpenApi(),
+        )
+        val codeGenResult = org.jetbrains.dataframe.impl.codeGen.CodeGenerator.urlCodeGenReader(url, formats)
+        when (codeGenResult) {
+            is org.jetbrains.kotlinx.dataframe.impl.codeGen.CodeGenerationReadResult.Success -> {
+                val readDfMethod = codeGenResult.getReadDfMethod(url.toExternalForm())
+                val code = readDfMethod.additionalImports.joinToString("\n") + 
+                    "\n" + 
+                    codeGenResult.code.converter(name)
+
+                EXECUTE(code)
+                DISPLAY("Data schema successfully imported as ${'$'}name")
+            }
+
+            is org.jetbrains.kotlinx.dataframe.impl.codeGen.CodeGenerationReadResult.Error -> {
+                DISPLAY("Failed to read data schema from ${'$'}url: ${'$'}{codeGenResult.reason}")
+            }
+        }
+    }
+
+    /** Import the type-only data schema from [path]. */
+    fun importDataSchema(path: String, name: String): Unit = importDataSchema(URL(path), name)
+
+    /** Import the type-only data schema from [file]. */
+    fun importDataSchema(file: File, name: String): Unit = importDataSchema(file.toURI().toURL(), name)
+    """.trimIndent()
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/jupyter/kernelUpdateMessages.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/jupyter/kernelUpdateMessages.kt
new file mode 100644
index 000000000..dddf30d04
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/jupyter/kernelUpdateMessages.kt
@@ -0,0 +1,27 @@
+package org.jetbrains.kotlinx.dataframe.jupyter
+
+import org.jetbrains.kotlinx.jupyter.api.JupyterClientType
+import org.jetbrains.kotlinx.jupyter.api.JupyterClientType.DATALORE
+import org.jetbrains.kotlinx.jupyter.api.JupyterClientType.KOTLIN_NOTEBOOK
+import org.jetbrains.kotlinx.jupyter.api.KotlinKernelVersion
+
+private const val UPDATING_DATALORE_URL = "https://github.com/Kotlin/kotlin-jupyter/tree/master#datalore"
+private const val UPDATING_KOTLIN_NOTEBOOK_URL = "https://github.com/Kotlin/kotlin-jupyter#kotlin-notebook"
+private const val UPDATING = "https://github.com/Kotlin/kotlin-jupyter/tree/master#updating"
+
+internal fun getKernelUpdateMessage(
+    kernelVersion: KotlinKernelVersion,
+    minKernelVersion: String,
+    clientType: JupyterClientType,
+): String =
+    buildString {
+        append("Your Kotlin Jupyter kernel version appears to be out of date (version $kernelVersion). ")
+        appendLine("Please update it to version $minKernelVersion or newer to be able to use DataFrame.")
+        append("Follow the instructions at: ")
+
+        when (clientType) {
+            DATALORE -> appendLine(UPDATING_DATALORE_URL)
+            KOTLIN_NOTEBOOK -> appendLine(UPDATING_KOTLIN_NOTEBOOK_URL)
+            else -> appendLine(UPDATING)
+        }
+    }
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/math/cumsum.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/math/cumsum.kt
new file mode 100644
index 000000000..58ef59329
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/math/cumsum.kt
@@ -0,0 +1,149 @@
+package org.jetbrains.kotlinx.dataframe.math
+
+import org.jetbrains.kotlinx.dataframe.DataColumn
+import org.jetbrains.kotlinx.dataframe.api.isNA
+import org.jetbrains.kotlinx.dataframe.api.map
+import java.math.BigDecimal
+
+internal val defaultCumSumSkipNA: Boolean = true
+
+@JvmName("doubleCumsum")
+internal fun DataColumn<Double>.cumSum(skipNA: Boolean = defaultCumSumSkipNA): DataColumn<Double> {
+    var sum = .0
+    return map {
+        if (skipNA && it.isNaN()) {
+            it
+        } else {
+            sum += it
+            sum
+        }
+    }
+}
+
+@JvmName("cumsumDoubleNullable")
+internal fun DataColumn<Double?>.cumSum(skipNA: Boolean = defaultCumSumSkipNA): DataColumn<Double> {
+    var sum = .0
+    return map {
+        if (skipNA && it.isNA) {
+            Double.NaN
+        } else {
+            sum += it ?: Double.NaN
+            sum
+        }
+    }
+}
+
+@JvmName("floatCumsum")
+internal fun DataColumn<Float>.cumSum(skipNA: Boolean = defaultCumSumSkipNA): DataColumn<Float> {
+    var sum = .0f
+    return map {
+        if (skipNA && it.isNaN()) {
+            it
+        } else {
+            sum += it
+            sum
+        }
+    }
+}
+
+internal fun DataColumn<Float?>.cumSum(skipNA: Boolean = defaultCumSumSkipNA): DataColumn<Float> {
+    var sum = .0f
+    return map {
+        if (skipNA && it.isNA) {
+            Float.NaN
+        } else {
+            sum += it ?: Float.NaN
+            sum
+        }
+    }
+}
+
+@JvmName("intCumsum")
+internal fun DataColumn<Int>.cumSum(): DataColumn<Int> {
+    var sum = 0
+    return map {
+        sum += it
+        sum
+    }
+}
+
+@JvmName("intCumsum")
+internal fun DataColumn<Int?>.cumSum(skipNA: Boolean = defaultCumSumSkipNA): DataColumn<Int?> {
+    var sum = 0
+    var fillNull = false
+    return map {
+        when {
+            it == null -> {
+                if (!skipNA) fillNull = true
+                null
+            }
+
+            fillNull -> null
+
+            else -> {
+                sum += it
+                sum
+            }
+        }
+    }
+}
+
+@JvmName("longCumsum")
+internal fun DataColumn<Long>.cumSum(): DataColumn<Long> {
+    var sum = 0L
+    return map {
+        sum += it
+        sum
+    }
+}
+
+@JvmName("cumsumLongNullable")
+internal fun DataColumn<Long?>.cumSum(skipNA: Boolean = defaultCumSumSkipNA): DataColumn<Long?> {
+    var sum = 0L
+    var fillNull = false
+    return map {
+        when {
+            it == null -> {
+                if (!skipNA) fillNull = true
+                null
+            }
+
+            fillNull -> null
+
+            else -> {
+                sum += it
+                sum
+            }
+        }
+    }
+}
+
+@JvmName("bigDecimalCumsum")
+internal fun DataColumn<BigDecimal>.cumSum(): DataColumn<BigDecimal> {
+    var sum = BigDecimal.ZERO
+    return map {
+        sum += it
+        sum
+    }
+}
+
+@JvmName("cumsumBigDecimalNullable")
+internal fun DataColumn<BigDecimal?>.cumSum(skipNA: Boolean = defaultCumSumSkipNA): DataColumn<BigDecimal?> {
+    var sum = BigDecimal.ZERO
+    var fillNull = false
+    return map {
+        when {
+            it == null -> {
+                if (!skipNA) fillNull = true
+                null
+            }
+
+            fillNull -> null
+
+            else -> {
+                sum += it
+                sum
+            }
+        }
+    }
+}
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/math/mean.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/math/mean.kt
new file mode 100644
index 000000000..c7c6e9596
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/math/mean.kt
@@ -0,0 +1,146 @@
+package org.jetbrains.kotlinx.dataframe.math
+
+import org.jetbrains.kotlinx.dataframe.api.skipNA_default
+import org.jetbrains.kotlinx.dataframe.impl.renderType
+import java.math.BigDecimal
+import kotlin.reflect.KType
+import kotlin.reflect.full.withNullability
+
+@PublishedApi
+internal fun <T : Number> Iterable<T>.mean(type: KType, skipNA: Boolean = skipNA_default): Double =
+    asSequence().mean(type, skipNA)
+
+internal fun <T : Number> Sequence<T>.mean(type: KType, skipNA: Boolean = skipNA_default): Double {
+    if (type.isMarkedNullable) {
+        return filterNotNull().mean(type.withNullability(false), skipNA)
+    }
+    return when (type.classifier) {
+        Double::class -> (this as Sequence<Double>).mean(skipNA)
+
+        Float::class -> (this as Sequence<Float>).mean(skipNA)
+
+        Int::class -> (this as Sequence<Int>).map { it.toDouble() }.mean(false)
+
+        // for integer values NA is not possible
+        Short::class -> (this as Sequence<Short>).map { it.toDouble() }.mean(false)
+
+        Byte::class -> (this as Sequence<Byte>).map { it.toDouble() }.mean(false)
+
+        Long::class -> (this as Sequence<Long>).map { it.toDouble() }.mean(false)
+
+        BigDecimal::class -> (this as Sequence<BigDecimal>).map { it.toDouble() }.mean(skipNA)
+
+        Number::class -> (this as Sequence<Number>).map { it.toDouble() }.mean(skipNA)
+
+        // this means the sequence is empty
+        Nothing::class -> Double.NaN
+
+        else -> throw IllegalArgumentException("Unable to compute the mean for type ${renderType(type)}")
+    }
+}
+
+public fun Sequence<Double>.mean(skipNA: Boolean = skipNA_default): Double {
+    var count = 0
+    var sum: Double = 0.toDouble()
+    for (element in this) {
+        if (element.isNaN()) {
+            if (skipNA) {
+                continue
+            } else {
+                return Double.NaN
+            }
+        }
+        sum += element
+        count++
+    }
+    return if (count > 0) sum / count else Double.NaN
+}
+
+@JvmName("meanFloat")
+public fun Sequence<Float>.mean(skipNA: Boolean = skipNA_default): Double {
+    var count = 0
+    var sum: Double = 0.toDouble()
+    for (element in this) {
+        if (element.isNaN()) {
+            if (skipNA) {
+                continue
+            } else {
+                return Double.NaN
+            }
+        }
+        sum += element
+        count++
+    }
+    return if (count > 0) sum / count else Double.NaN
+}
+
+@JvmName("doubleMean")
+public fun Iterable<Double>.mean(skipNA: Boolean = skipNA_default): Double = asSequence().mean(skipNA)
+
+@JvmName("floatMean")
+public fun Iterable<Float>.mean(skipNA: Boolean = skipNA_default): Double = asSequence().mean(skipNA)
+
+@JvmName("intMean")
+public fun Iterable<Int>.mean(): Double =
+    if (this is Collection) {
+        if (size > 0) sumOf { it.toDouble() } / size else Double.NaN
+    } else {
+        var count = 0
+        val sum = sumOf {
+            count++
+            it.toDouble()
+        }
+        if (count > 0) sum / count else Double.NaN
+    }
+
+@JvmName("shortMean")
+public fun Iterable<Short>.mean(): Double =
+    if (this is Collection) {
+        if (size > 0) sumOf { it.toDouble() } / size else Double.NaN
+    } else {
+        var count = 0
+        val sum = sumOf {
+            count++
+            it.toDouble()
+        }
+        if (count > 0) sum / count else Double.NaN
+    }
+
+@JvmName("byteMean")
+public fun Iterable<Byte>.mean(): Double =
+    if (this is Collection) {
+        if (size > 0) sumOf { it.toDouble() } / size else Double.NaN
+    } else {
+        var count = 0
+        val sum = sumOf {
+            count++
+            it.toDouble()
+        }
+        if (count > 0) sum / count else Double.NaN
+    }
+
+@JvmName("longMean")
+public fun Iterable<Long>.mean(): Double =
+    if (this is Collection) {
+        if (size > 0) sumOf { it.toDouble() } / size else Double.NaN
+    } else {
+        var count = 0
+        val sum = sumOf {
+            count++
+            it.toDouble()
+        }
+        if (count > 0) sum / count else Double.NaN
+    }
+
+@JvmName("bigDecimalMean")
+public fun Iterable<BigDecimal>.mean(): Double =
+    if (this is Collection) {
+        if (size > 0) sum().toDouble() / size else Double.NaN
+    } else {
+        var count = 0
+        val sum = sumOf {
+            count++
+            it.toDouble()
+        }
+        if (count > 0) sum / count else Double.NaN
+    }
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/math/median.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/math/median.kt
new file mode 100644
index 000000000..559b4027d
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/math/median.kt
@@ -0,0 +1,78 @@
+package org.jetbrains.kotlinx.dataframe.math
+
+import org.jetbrains.kotlinx.dataframe.impl.asList
+import java.math.BigDecimal
+import kotlin.reflect.KType
+import kotlin.reflect.typeOf
+
+public inline fun <reified T : Comparable<T>> Iterable<T>.medianOrNull(): T? = median(typeOf<T>())
+
+public inline fun <reified T : Comparable<T>> Iterable<T>.median(): T = medianOrNull()!!
+
+@PublishedApi
+internal inline fun <reified T : Comparable<T>> Iterable<T?>.median(type: KType): T? {
+    val list = if (type.isMarkedNullable) filterNotNull() else (this as Iterable<T>).asList()
+    val size = list.size
+    if (size == 0) return null
+    val index = size / 2
+    if (index == 0 || size % 2 == 1) return list.quickSelect(index)
+    return when (type.classifier) {
+        Double::class -> ((list.quickSelect(index - 1) as Double + list.quickSelect(index) as Double) / 2.0) as T
+
+        Int::class -> ((list.quickSelect(index - 1) as Int + list.quickSelect(index) as Int) / 2) as T
+
+        Long::class -> ((list.quickSelect(index - 1) as Long + list.quickSelect(index) as Long) / 2L) as T
+
+        Byte::class -> ((list.quickSelect(index - 1) as Byte + list.quickSelect(index) as Byte) / 2).toByte() as T
+
+        BigDecimal::class -> (
+            (list.quickSelect(index - 1) as BigDecimal + list.quickSelect(index) as BigDecimal) / BigDecimal(2)
+        ) as T
+
+        else -> list.quickSelect(index - 1)
+    }
+}
+
+@PublishedApi
+internal fun <T : Comparable<T>> List<T>.quickSelect(k: Int): T {
+    if (k < 0 || k >= size) throw IndexOutOfBoundsException("k = $k, size = $size")
+
+    var list = this
+    var temp = mutableListOf<T>()
+    var less = mutableListOf<T>()
+    var k = k
+    var greater = mutableListOf<T>()
+    while (list.size > 1) {
+        var equal = 0
+        val x = list.random()
+        greater.clear()
+        less.clear()
+        for (v in list) {
+            val comp = v.compareTo(x)
+            when {
+                comp < 0 -> less.add(v)
+                comp > 0 -> greater.add(v)
+                else -> equal++
+            }
+        }
+        when {
+            k < less.size -> {
+                list = less
+                less = temp
+                temp = list
+            }
+
+            k < less.size + equal -> {
+                return x
+            }
+
+            else -> {
+                list = greater
+                greater = temp
+                temp = list
+                k -= less.size + equal
+            }
+        }
+    }
+    return list[0]
+}
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/math/minmax.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/math/minmax.kt
new file mode 100644
index 000000000..fb0f0871a
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/math/minmax.kt
@@ -0,0 +1,25 @@
+package org.jetbrains.kotlinx.dataframe.math
+
+import java.math.BigDecimal
+import kotlin.reflect.KType
+import kotlin.reflect.jvm.jvmErasure
+
+internal fun <T : Number> Iterable<T>.min(type: KType) =
+    when (type.jvmErasure) {
+        Double::class -> (this as Iterable<Double>).minOrNull()
+        Float::class -> (this as Iterable<Float>).minOrNull()
+        Int::class, Short::class, Byte::class -> (this as Iterable<Int>).minOrNull()
+        Long::class -> (this as Iterable<Long>).minOrNull()
+        BigDecimal::class -> (this as Iterable<BigDecimal>).minOrNull()
+        else -> throw IllegalArgumentException()
+    }
+
+internal fun <T : Number> Iterable<T>.max(type: KType) =
+    when (type.jvmErasure) {
+        Double::class -> (this as Iterable<Double>).maxOrNull()
+        Float::class -> (this as Iterable<Float>).maxOrNull()
+        Int::class, Short::class, Byte::class -> (this as Iterable<Int>).maxOrNull()
+        Long::class -> (this as Iterable<Long>).maxOrNull()
+        BigDecimal::class -> (this as Iterable<BigDecimal>).maxOrNull()
+        else -> throw IllegalArgumentException()
+    }
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/math/std.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/math/std.kt
new file mode 100644
index 000000000..119f0e225
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/math/std.kt
@@ -0,0 +1,49 @@
+package org.jetbrains.kotlinx.dataframe.math
+
+import org.jetbrains.kotlinx.dataframe.api.ddof_default
+import org.jetbrains.kotlinx.dataframe.api.skipNA_default
+import org.jetbrains.kotlinx.dataframe.impl.renderType
+import java.math.BigDecimal
+import kotlin.reflect.KType
+import kotlin.reflect.full.withNullability
+
+@PublishedApi
+internal fun <T : Number> Iterable<T?>.std(
+    type: KType,
+    skipNA: Boolean = skipNA_default,
+    ddof: Int = ddof_default,
+): Double {
+    if (type.isMarkedNullable) {
+        return when {
+            skipNA -> filterNotNull().std(type = type.withNullability(false), skipNA = true, ddof = ddof)
+            contains(null) -> Double.NaN
+            else -> std(type = type.withNullability(false), skipNA = false, ddof = ddof)
+        }
+    }
+    return when (type.classifier) {
+        Double::class -> (this as Iterable<Double>).std(skipNA, ddof)
+        Float::class -> (this as Iterable<Float>).std(skipNA, ddof)
+        Int::class, Short::class, Byte::class -> (this as Iterable<Int>).std(ddof)
+        Long::class -> (this as Iterable<Long>).std(ddof)
+        BigDecimal::class -> (this as Iterable<BigDecimal>).std(ddof)
+        Nothing::class -> Double.NaN
+        else -> throw IllegalArgumentException("Unable to compute the std for type ${renderType(type)}")
+    }
+}
+
+@JvmName("doubleStd")
+public fun Iterable<Double>.std(skipNA: Boolean = skipNA_default, ddof: Int = ddof_default): Double =
+    varianceAndMean(skipNA)?.std(ddof) ?: Double.NaN
+
+@JvmName("floatStd")
+public fun Iterable<Float>.std(skipNA: Boolean = skipNA_default, ddof: Int = ddof_default): Double =
+    varianceAndMean(skipNA)?.std(ddof) ?: Double.NaN
+
+@JvmName("intStd")
+public fun Iterable<Int>.std(ddof: Int = ddof_default): Double = varianceAndMean().std(ddof)
+
+@JvmName("longStd")
+public fun Iterable<Long>.std(ddof: Int = ddof_default): Double = varianceAndMean().std(ddof)
+
+@JvmName("bigDecimalStd")
+public fun Iterable<BigDecimal>.std(ddof: Int = ddof_default): Double = varianceAndMean().std(ddof)
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/math/stdMean.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/math/stdMean.kt
new file mode 100644
index 000000000..ee95c6d1a
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/math/stdMean.kt
@@ -0,0 +1,116 @@
+@file:Suppress("DuplicatedCode")
+
+package org.jetbrains.kotlinx.dataframe.math
+
+import org.jetbrains.kotlinx.dataframe.api.skipNA_default
+import java.math.BigDecimal
+import kotlin.math.sqrt
+
+public data class BasicStats(val count: Int, val mean: Double, val variance: Double) {
+
+    public fun std(ddof: Int): Double {
+        if (count <= ddof) return Double.NaN
+        return sqrt(variance / (count - ddof))
+    }
+}
+
+@JvmName("doubleVarianceAndMean")
+public fun Iterable<Double>.varianceAndMean(skipNA: Boolean = skipNA_default): BasicStats? {
+    var count = 0
+    var sum = .0
+    for (element in this) {
+        if (element.isNaN()) {
+            if (skipNA) {
+                continue
+            } else {
+                return null
+            }
+        }
+        sum += element
+        count++
+    }
+    val mean = sum / count
+    var variance = .0
+    for (element in this) {
+        if (element.isNaN()) continue
+        val diff = element - mean
+        variance += diff * diff
+    }
+    return BasicStats(count, mean, variance)
+}
+
+@JvmName("floatVarianceAndMean")
+public fun Iterable<Float>.varianceAndMean(skipNA: Boolean = skipNA_default): BasicStats? {
+    var count = 0
+    var sum = .0
+    for (element in this) {
+        if (element.isNaN()) {
+            if (skipNA) {
+                continue
+            } else {
+                return null
+            }
+        }
+        sum += element
+        count++
+    }
+    val mean = sum / count
+    var variance = .0
+    for (element in this) {
+        if (element.isNaN()) continue
+        val diff = element - mean
+        variance += diff * diff
+    }
+    return BasicStats(count, mean, variance)
+}
+
+@JvmName("intVarianceAndMean")
+public fun Iterable<Int>.varianceAndMean(): BasicStats {
+    var count = 0
+    var sum = .0
+    for (element in this) {
+        sum += element
+        count++
+    }
+    val mean = sum / count
+    var variance = .0
+    for (element in this) {
+        val diff = element - mean
+        variance += diff * diff
+    }
+    return BasicStats(count, mean, variance)
+}
+
+@JvmName("longVarianceAndMean")
+public fun Iterable<Long>.varianceAndMean(): BasicStats {
+    var count = 0
+    var sum = .0
+    for (element in this) {
+        sum += element
+        count++
+    }
+    val mean = sum / count
+    var variance = .0
+    for (element in this) {
+        val diff = element - mean
+        variance += diff * diff
+    }
+    return BasicStats(count, mean, variance)
+}
+
+@JvmName("bigDecimalVarianceAndMean")
+public fun Iterable<BigDecimal>.varianceAndMean(): BasicStats {
+    var count = 0
+    var sum = BigDecimal.ZERO
+    for (element in this) {
+        sum += element
+        count++
+    }
+    val mean = sum.div(count.toBigDecimal())
+    var variance = BigDecimal.ZERO
+    for (element in this) {
+        val diff = element - mean
+        variance += diff * diff
+    }
+    return BasicStats(count, mean.toDouble(), variance.toDouble())
+}
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/math/sum.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/math/sum.kt
new file mode 100644
index 000000000..d26c155a3
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/math/sum.kt
@@ -0,0 +1,60 @@
+package org.jetbrains.kotlinx.dataframe.math
+
+import java.math.BigDecimal
+import kotlin.reflect.KType
+
+@PublishedApi
+internal fun <T, R : Number> Iterable<T>.sumOf(type: KType, selector: (T) -> R?): R {
+    if (type.isMarkedNullable) {
+        val seq = asSequence().mapNotNull(selector).asIterable()
+        return seq.sum(type)
+    }
+    return when (type.classifier) {
+        Double::class -> sumOf(selector as ((T) -> Double)) as R
+        Int::class -> sumOf(selector as ((T) -> Int)) as R
+        Long::class -> sumOf(selector as ((T) -> Long)) as R
+        BigDecimal::class -> sumOf(selector as ((T) -> BigDecimal)) as R
+        else -> TODO()
+    }
+}
+
+@PublishedApi
+internal fun <T : Number> Iterable<T>.sum(type: KType): T =
+    when (type.classifier) {
+        Double::class -> (this as Iterable<Double>).sum() as T
+        Float::class -> (this as Iterable<Float>).sum() as T
+        Int::class, Short::class, Byte::class -> (this as Iterable<Int>).sum() as T
+        Long::class -> (this as Iterable<Long>).sum() as T
+        BigDecimal::class -> (this as Iterable<BigDecimal>).sum() as T
+        else -> throw IllegalArgumentException("Sum is not supported for $type")
+    }
+
+@JvmName("sumNullableT")
+@PublishedApi
+internal fun <T : Number> Iterable<T?>.sum(type: KType): T =
+    when (type.classifier) {
+        Double::class -> (this as Iterable<Double?>).asSequence().filterNotNull().sum() as T
+        Float::class -> (this as Iterable<Float?>).asSequence().filterNotNull().sum() as T
+        Int::class, Short::class, Byte::class -> (this as Iterable<Int?>).asSequence().filterNotNull().sum() as T
+        Long::class -> (this as Iterable<Long?>).asSequence().filterNotNull().sum() as T
+        BigDecimal::class -> (this as Iterable<BigDecimal?>).asSequence().filterNotNull().sum() as T
+        else -> TODO()
+    }
+
+@PublishedApi
+internal fun Iterable<BigDecimal>.sum(): BigDecimal {
+    var sum: BigDecimal = BigDecimal.ZERO
+    for (element in this) {
+        sum += element
+    }
+    return sum
+}
+
+@PublishedApi
+internal fun Sequence<BigDecimal>.sum(): BigDecimal {
+    var sum: BigDecimal = BigDecimal.ZERO
+    for (element in this) {
+        sum += element
+    }
+    return sum
+}
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/schema/ColumnSchema.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/schema/ColumnSchema.kt
new file mode 100644
index 000000000..0f5835ee5
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/schema/ColumnSchema.kt
@@ -0,0 +1,96 @@
+package org.jetbrains.kotlinx.dataframe.schema
+
+import org.jetbrains.kotlinx.dataframe.AnyFrame
+import org.jetbrains.kotlinx.dataframe.AnyRow
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.DataRow
+import org.jetbrains.kotlinx.dataframe.columns.ColumnKind
+import kotlin.reflect.KType
+import kotlin.reflect.full.isSubtypeOf
+import kotlin.reflect.full.isSupertypeOf
+import kotlin.reflect.typeOf
+
+public abstract class ColumnSchema {
+
+    /** Either [Value] or [Group] or [Frame]. */
+    public abstract val kind: ColumnKind
+
+    /** Whether the column is nullable. Is always `false` for [Group]. */
+    public abstract val nullable: Boolean
+
+    /**
+     * The type of the column.
+     * For [Value] this is the common base type associated with all the values in the column.
+     * For [Group] this is [AnyRow].
+     * For [Frame] this is [AnyFrame].
+     */
+    public abstract val type: KType
+
+    /**
+     * The type associated with the contents of the column.
+     * For [Value] this is irrelevant and thus `null`. Use [type] instead.
+     * For [Group] this is the common base type associated with all the [DataRow]s in the column.
+     * For [Frame] this is the common base type associated with all the [DataFrame]s in the column.
+     */
+    public abstract val contentType: KType?
+
+    public class Value(public override val type: KType) : ColumnSchema() {
+        override val kind: ColumnKind = ColumnKind.Value
+        override val nullable: Boolean = type.isMarkedNullable
+        override val contentType: KType? = null
+
+        public fun compare(other: Value): CompareResult =
+            when {
+                type == other.type -> CompareResult.Equals
+                type.isSubtypeOf(other.type) -> CompareResult.IsDerived
+                type.isSupertypeOf(other.type) -> CompareResult.IsSuper
+                else -> CompareResult.None
+            }
+    }
+
+    public class Group(public val schema: DataFrameSchema, override val contentType: KType?) : ColumnSchema() {
+        override val kind: ColumnKind = ColumnKind.Group
+
+        /** A column group is never null, instead, make the columns inside nullable. */
+        override val nullable: Boolean = false
+        override val type: KType get() = typeOf<AnyRow>()
+
+        public fun compare(other: Group): CompareResult = schema.compare(other.schema)
+    }
+
+    public class Frame(
+        public val schema: DataFrameSchema,
+        override val nullable: Boolean,
+        override val contentType: KType?,
+    ) : ColumnSchema() {
+        public override val kind: ColumnKind = ColumnKind.Frame
+        override val type: KType get() = typeOf<AnyFrame>()
+
+        public fun compare(other: Frame): CompareResult =
+            schema.compare(other.schema).combine(CompareResult.compareNullability(nullable, other.nullable))
+    }
+
+    /** Checks equality just on kind, type, or schema. */
+    override fun equals(other: Any?): Boolean {
+        val otherType = other as? ColumnSchema ?: return false
+        if (otherType.kind != kind) return false
+        if (otherType.nullable != nullable) return false
+        return when (this) {
+            is Value -> type == (otherType as Value).type
+            is Group -> schema == (otherType as Group).schema
+            is Frame -> schema == (otherType as Frame).schema
+            else -> throw NotImplementedError()
+        }
+    }
+
+    public fun compare(other: ColumnSchema): CompareResult {
+        if (kind != other.kind) return CompareResult.None
+        if (this === other) return CompareResult.Equals
+        return when (this) {
+            is Value -> compare(other as Value)
+            is Group -> compare(other as Group)
+            is Frame -> compare(other as Frame)
+            else -> throw NotImplementedError()
+        }
+    }
+}
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/schema/CompareResult.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/schema/CompareResult.kt
new file mode 100644
index 000000000..6f9a63d59
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/schema/CompareResult.kt
@@ -0,0 +1,30 @@
+package org.jetbrains.kotlinx.dataframe.schema
+
+public enum class CompareResult {
+    Equals,
+    IsSuper,
+    IsDerived,
+    None,
+    ;
+
+    public fun isSuperOrEqual(): Boolean = this == Equals || this == IsSuper
+
+    public fun isEqual(): Boolean = this == Equals
+
+    public fun combine(other: CompareResult): CompareResult =
+        when (this) {
+            Equals -> other
+            None -> None
+            IsDerived -> if (other == Equals || other == IsDerived) this else None
+            IsSuper -> if (other == Equals || other == IsSuper) this else None
+        }
+
+    public companion object {
+        public fun compareNullability(thisIsNullable: Boolean, otherIsNullable: Boolean): CompareResult =
+            when {
+                thisIsNullable == otherIsNullable -> Equals
+                thisIsNullable -> IsSuper
+                else -> IsDerived
+            }
+    }
+}
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/schema/DataFrameSchema.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/schema/DataFrameSchema.kt
new file mode 100644
index 000000000..d364f0448
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/schema/DataFrameSchema.kt
@@ -0,0 +1,8 @@
+package org.jetbrains.kotlinx.dataframe.schema
+
+public interface DataFrameSchema {
+
+    public val columns: Map<String, ColumnSchema>
+
+    public fun compare(other: DataFrameSchema): CompareResult
+}
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/util/deprecationMessages.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/util/deprecationMessages.kt
new file mode 100644
index 000000000..05951691a
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/util/deprecationMessages.kt
@@ -0,0 +1,37 @@
+package org.jetbrains.kotlinx.dataframe.util
+
+/*
+ * This file contains deprecation messages for the whole core module.
+ * After each release, all messages should be reviewed and updated.
+ * Level.WARNING -> Level.ERROR
+ * Level.ERROR -> Remove
+ */
+
+// region WARNING in 0.15, ERROR in 0.16
+
+private const val MESSAGE_0_16 = "Will be removed in 0.16."
+
+internal const val DF_READ_NO_CSV = "This function is deprecated and should be replaced with `readCSV`. $MESSAGE_0_16"
+internal const val DF_READ_NO_CSV_REPLACE =
+    "this.readCSV(fileOrUrl, delimiter, header, colTypes, skipLines, readLines, duplicate, charset)"
+
+// endregion
+
+// region WARNING in 0.16, ERROR in 0.17
+
+private const val MESSAGE_0_17 = "Will be removed in 0.17."
+
+// endregion
+
+// region keep across releases
+
+internal const val IDENTITY_FUNCTION = "This overload is an identity function and can be omitted."
+
+internal const val COL_REPLACE = "col"
+
+internal const val ALL_COLS_EXCEPT =
+    "This overload is blocked to prevent issues with column accessors. Use the `{}` overload instead."
+internal const val ALL_COLS_REPLACE = "allColsExcept { other }"
+internal const val ALL_COLS_REPLACE_VARARG = "allColsExcept { others.toColumnSet() }"
+
+// endregion
diff --git a/core/generated-sources/src/test/java/org/jetbrains/kotlinx/dataframe/api/JavaPojo.java b/core/generated-sources/src/test/java/org/jetbrains/kotlinx/dataframe/api/JavaPojo.java
new file mode 100644
index 000000000..8eccd32fa
--- /dev/null
+++ b/core/generated-sources/src/test/java/org/jetbrains/kotlinx/dataframe/api/JavaPojo.java
@@ -0,0 +1,79 @@
+package org.jetbrains.kotlinx.dataframe.api;
+
+import java.util.Objects;
+
+public class JavaPojo {
+
+    private int a;
+    private String b;
+    private Integer c;
+    private Number d;
+
+    public JavaPojo() {}
+
+    public JavaPojo(Number d, Integer c, String b, int a) {
+        this.a = a;
+        this.b = b;
+        this.c = c;
+        this.d = d;
+    }
+
+    public int getA() {
+        return a;
+    }
+
+    public void setA(int a) {
+        this.a = a;
+    }
+
+    public String getB() {
+        return b;
+    }
+
+    public void setB(String b) {
+        this.b = b;
+    }
+
+    public Integer getC() {
+        return c;
+    }
+
+    public void setC(Integer c) {
+        this.c = c;
+    }
+
+    public Number getD() {
+        return d;
+    }
+
+    public void setD(Number d) {
+        this.d = d;
+    }
+
+    public static int getNot() {
+        return 1;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (!(o instanceof JavaPojo)) return false;
+        JavaPojo javaPojo = (JavaPojo) o;
+        return a == javaPojo.a && Objects.equals(b, javaPojo.b) && Objects.equals(c, javaPojo.c) && Objects.equals(d, javaPojo.d);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(a, b, c, d);
+    }
+
+    @Override
+    public String toString() {
+        return "JavaPojo{" +
+            "a=" + a +
+            ", b='" + b + '\'' +
+            ", c=" + c +
+            ", d=" + d +
+            '}';
+    }
+}
diff --git a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/Utils.kt b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/Utils.kt
new file mode 100644
index 000000000..3865c3634
--- /dev/null
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/Utils.kt
@@ -0,0 +1,35 @@
+package org.jetbrains.kotlinx.dataframe
+
+import kotlinx.serialization.json.Json
+import kotlinx.serialization.json.JsonObject
+import kotlinx.serialization.json.jsonObject
+import org.jetbrains.kotlinx.dataframe.api.print
+import org.jetbrains.kotlinx.dataframe.api.schema
+import org.jetbrains.kotlinx.dataframe.io.renderToString
+import org.jetbrains.kotlinx.dataframe.types.UtilTests
+import java.net.URL
+
+fun testResource(resourcePath: String): URL = UtilTests::class.java.classLoader.getResource(resourcePath)!!
+
+fun testCsv(csvName: String) = testResource("$csvName.csv")
+
+fun testJson(jsonName: String) = testResource("$jsonName.json")
+
+fun <T : DataFrame<*>> T.toDebugString(rowsLimit: Int = 20) =
+    """
+    ${renderToString(borders = true, title = true, columnTypes = true, valueLimit = -1, rowsLimit = rowsLimit)}
+    
+    ${schema()}
+    """.trimIndent()
+
+/**
+ * Prints dataframe to console with borders, title, column types and schema
+ */
+fun <T : DataFrame<*>> T.alsoDebug(println: String? = null, rowsLimit: Int = 20): T =
+    apply {
+        println?.let { println(it) }
+        print(borders = true, title = true, columnTypes = true, valueLimit = -1, rowsLimit = rowsLimit)
+        schema().print()
+    }
+
+fun parseJsonStr(jsonStr: String): JsonObject = Json.parseToJsonElement(jsonStr).jsonObject
diff --git a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/ColumnPath.kt b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/ColumnPath.kt
new file mode 100644
index 000000000..361099157
--- /dev/null
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/ColumnPath.kt
@@ -0,0 +1,46 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import io.kotest.matchers.shouldBe
+import org.jetbrains.kotlinx.dataframe.columns.dropOverlappingStartOfChild
+import org.jetbrains.kotlinx.dataframe.columns.dropStartWrt
+import org.jetbrains.kotlinx.dataframe.samples.api.TestBase
+import org.junit.Test
+
+class ColumnPathTests : TestBase() {
+
+    @Test
+    fun `should trim overlapping start of first list from the end of second list`() {
+        val parent = pathOf("something", "name", "firstName")
+        val child = pathOf("name", "firstName", "secondName")
+
+        dropOverlappingStartOfChild(parent, child) shouldBe listOf("secondName")
+        child.dropStartWrt(parent) shouldBe pathOf("secondName")
+    }
+
+    @Test
+    fun `should return first list as is when there is no overlap`() {
+        val parent = pathOf("city", "country")
+        val child = pathOf("name", "firstName", "secondName")
+
+        dropOverlappingStartOfChild(parent, child) shouldBe listOf("name", "firstName", "secondName")
+        child.dropStartWrt(parent) shouldBe pathOf("name", "firstName", "secondName")
+    }
+
+    @Test
+    fun `should return empty list when first list is completely overlapped`() {
+        val parent = pathOf("city", "name", "firstName")
+        val child = pathOf("name", "firstName")
+
+        dropOverlappingStartOfChild(parent, child) shouldBe emptyList()
+        child.dropStartWrt(parent) shouldBe pathOf()
+    }
+
+    @Test
+    fun `if parent is empty`() {
+        val parent = pathOf()
+        val child = pathOf("name", "firstName")
+
+        dropOverlappingStartOfChild(parent, child) shouldBe listOf("name", "firstName")
+        child.dropStartWrt(parent) shouldBe pathOf("name", "firstName")
+    }
+}
diff --git a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/ColumnsSelectionDsl.kt b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/ColumnsSelectionDsl.kt
new file mode 100644
index 000000000..45e6434a4
--- /dev/null
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/ColumnsSelectionDsl.kt
@@ -0,0 +1,29 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.annotations.DataSchema
+import org.jetbrains.kotlinx.dataframe.samples.api.TestBase
+import org.jetbrains.kotlinx.dataframe.samples.api.firstName
+import org.jetbrains.kotlinx.dataframe.samples.api.lastName
+import org.jetbrains.kotlinx.dataframe.samples.api.name
+
+open class ColumnsSelectionDslTests : TestBase() {
+
+    @DataSchema
+    interface PersonWithFrame : Person {
+        val frameCol: DataFrame<Person>
+    }
+
+    protected val frameCol by frameColumn<Person>()
+
+    protected val dfWithFrames = df
+        .add { expr { df } into frameCol }
+        .convert { name }.to {
+            val firstName by it.asColumnGroup().firstName
+            val lastName by it.asColumnGroup().lastName
+
+            val frameCol by it.map { df }.asFrameColumn()
+
+            dataFrameOf(firstName, lastName, frameCol).asColumnGroup("name")
+        }
+}
diff --git a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/add.kt b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/add.kt
new file mode 100644
index 000000000..4f164215d
--- /dev/null
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/add.kt
@@ -0,0 +1,36 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import io.kotest.assertions.throwables.shouldThrow
+import io.kotest.matchers.shouldBe
+import org.jetbrains.kotlinx.dataframe.AnyFrame
+import org.junit.Test
+import kotlin.reflect.typeOf
+
+class AddTests {
+
+    @Test
+    fun `add with new`() {
+        val x by columnOf(7, 2, 0, 3, 4, 2, 5, 0, 3, 4)
+        val df = dataFrameOf(x)
+        val added = df.add("Y") { if (x() == 0) 0 else (prev()?.newValue() ?: 0) + 1 }
+        val expected = listOf(1, 2, 0, 1, 2, 3, 4, 0, 1, 2)
+        added["Y"].values() shouldBe expected
+    }
+
+    @Test
+    fun `throw for newValue at the next row`() {
+        val x by columnOf(7, 2, 0, 3, 4, 2, 5, 0, 3, 4)
+        val df = dataFrameOf(x)
+        shouldThrow<IndexOutOfBoundsException> {
+            df.add("y") { next()?.newValue() ?: 1 }
+        }
+    }
+
+    private fun <T> AnyFrame.addValue(value: T) = add("value") { listOf(value) }
+
+    @Test
+    fun `add with generic function`() {
+        val df = dataFrameOf("a")(1).addValue(2)
+        df["value"].type() shouldBe typeOf<List<Any?>>()
+    }
+}
diff --git a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/all.kt b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/all.kt
new file mode 100644
index 000000000..ec74594b3
--- /dev/null
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/all.kt
@@ -0,0 +1,366 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import io.kotest.assertions.throwables.shouldThrow
+import io.kotest.matchers.shouldBe
+import org.intellij.lang.annotations.Language
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.alsoDebug
+import org.jetbrains.kotlinx.dataframe.io.readJsonStr
+import org.jetbrains.kotlinx.dataframe.samples.api.age
+import org.jetbrains.kotlinx.dataframe.samples.api.city
+import org.jetbrains.kotlinx.dataframe.samples.api.firstName
+import org.jetbrains.kotlinx.dataframe.samples.api.isHappy
+import org.jetbrains.kotlinx.dataframe.samples.api.lastName
+import org.jetbrains.kotlinx.dataframe.samples.api.name
+import org.jetbrains.kotlinx.dataframe.samples.api.secondName
+import org.jetbrains.kotlinx.dataframe.samples.api.thirdName
+import org.jetbrains.kotlinx.dataframe.samples.api.weight
+import org.junit.Test
+
+class AllTests : ColumnsSelectionDslTests() {
+
+    @Test
+    fun `all exceptions`() {
+        shouldThrow<IllegalArgumentException> {
+            df.select { "age".allCols() }
+        }
+        shouldThrow<IllegalArgumentException> {
+            df.select { "age".allColsBefore("") }
+        }
+        shouldThrow<IllegalArgumentException> {
+            df.select { "age".allColsAfter("") }
+        }
+        shouldThrow<IllegalArgumentException> {
+            df.select { "age".allColsUpTo("") }
+        }
+        shouldThrow<IllegalArgumentException> {
+            df.select { "age".allColsFrom("") }
+        }
+
+        df.select { allAfter("nonExistent") } shouldBe df.select { none() }
+        df.select { allBefore("nonExistent") } shouldBe df.select { all() }
+        df.select { allUpTo("nonExistent") } shouldBe df.select { all() }
+        df.select { allFrom("nonExistent") } shouldBe df.select { none() }
+    }
+
+    @Test
+    fun all() {
+        listOf(
+            df.select { cols(name, age, city, weight, isHappy) },
+            df.select { all() },
+            df.select { all().all() },
+            df.select { cols().all() },
+            df.select { cols() },
+        ).shouldAllBeEqual()
+
+        listOf(
+            df.select { name.firstName and name.lastName },
+            df.select { name.allCols() },
+            df.select { name.allCols().all() },
+        ).shouldAllBeEqual()
+    }
+
+    @Test
+    fun `all subset top-level`() {
+        listOf(
+            df.select { name and age },
+            df.select { allBefore { city } },
+            df.select { allBefore { first { it.name.startsWith("c") } } },
+            df.select { allBefore(city) },
+            df.select { allBefore("city") },
+            df.select { allBefore(Person::city) },
+            df.select { allBefore(pathOf("city")) },
+            df.select { allUpTo { age } },
+            df.select { allUpTo { first { it.name.startsWith("a") } } },
+            df.select { allUpTo(age) },
+            df.select { allUpTo("age") },
+            df.select { allUpTo(Person::age) },
+            df.select { allUpTo(pathOf("age")) },
+        ).shouldAllBeEqual()
+
+        listOf(
+            df.select { weight and isHappy },
+            df.select { allAfter { city } },
+            df.select { allAfter { first { it.name.startsWith("c") } } },
+            df.select { allAfter(city) },
+            df.select { allAfter("city") },
+            df.select { allAfter(Person::city) },
+            df.select { allAfter(pathOf("city")) },
+            df.select { allFrom { weight } },
+            df.select { allFrom { first { it.name.startsWith("w") } } },
+            df.select { allFrom(weight) },
+            df.select { allFrom("weight") },
+            df.select { allFrom(Person::weight) },
+            df.select { allFrom(pathOf("weight")) },
+        ).shouldAllBeEqual()
+    }
+
+    @Test
+    fun `all on columnSet`() {
+        val cityAccessor = column<String?>("city")
+        val weightAccessor = column<Int?>("weight")
+        listOf(
+            df.select { weight and isHappy },
+            df.select { cols().allAfter { "city" in it.name } },
+            df.select { cols().allAfter { it.data == cityAccessor() } },
+            df.select { cols().allAfter { it.data == city } },
+            df.select { cols().allAfter(city) },
+            df.select { cols().allAfter(cityAccessor) },
+            df.select { cols().allAfter("city") },
+            df.select { cols().allAfter(Person::city) },
+            df.select { cols().allAfter(pathOf("city")) },
+            df.select { cols().allFrom { "weight" in it.name } },
+            df.select { cols().allFrom { it.data == weightAccessor() } },
+            df.select { cols().allFrom { it.data == weight } },
+            df.select { cols().allFrom(weight) },
+            df.select { cols().allFrom(weightAccessor) },
+            df.select { cols().allFrom("weight") },
+            df.select { cols().allFrom(Person::weight) },
+            df.select { cols().allFrom(pathOf("weight")) },
+        ).shouldAllBeEqual()
+
+        val ageAccessor = column<Int>("age")
+        listOf(
+            df.select { name and age },
+            df.select { cols().allBefore { "city" in it.name } },
+            df.select { cols().allBefore { it.data == cityAccessor() } },
+            df.select { cols().allBefore { it.data == city } },
+            df.select { cols().allBefore(city) },
+            df.select { cols().allBefore(cityAccessor) },
+            df.select { cols().allBefore("city") },
+            df.select { cols().allBefore(Person::city) },
+            df.select { cols().allBefore(pathOf("city")) },
+            df.select { cols().allUpTo { "age" in it.name } },
+            df.select { cols().allUpTo { it.data == ageAccessor() } },
+            df.select { cols().allUpTo { it.data == age } },
+            df.select { cols().allUpTo(age) },
+            df.select { cols().allUpTo(ageAccessor) },
+            df.select { cols().allUpTo("age") },
+            df.select { cols().allUpTo(Person::age) },
+            df.select { cols().allUpTo(pathOf("age")) },
+        ).shouldAllBeEqual()
+    }
+
+    @Suppress("CANDIDATE_CHOSEN_USING_OVERLOAD_RESOLUTION_BY_LAMBDA_ANNOTATION")
+    @Test
+    fun `all subset at lower level after and from`() {
+        listOf(
+            df.select { age },
+            df.select { colsOf<Int?>().allBefore(weight) },
+            df.select { allBefore(weight).colsOf<Int?>() },
+        ).shouldAllBeEqual()
+
+        val firstNameAccessor = column<String>("firstName")
+        val lastNameAccessor = column<String>("lastName")
+
+        listOf(
+            df.select { name.lastName },
+            df.select { name.allColsAfter { firstName } },
+            df.select { name.allColsAfter { firstNameAccessor } },
+            df.select { name.allColsAfter(name.firstName) },
+            df.select { name.allColsAfter(firstNameAccessor) },
+            df.select { name.allColsAfter("firstName") },
+            df.select { name.allColsAfter(Name::firstName) },
+            df.select { name.allColsAfter(pathOf("firstName")) },
+            df.select { name.allColsAfter(pathOf("name", "firstName")) },
+            df.select { "name".allColsAfter { firstNameAccessor } },
+            df.select { "name".allColsAfter(name.firstName) },
+            df.select { "name".allColsAfter(firstNameAccessor) },
+            df.select { "name".allColsAfter("firstName") },
+            df.select { "name".allColsAfter(Name::firstName) },
+            df.select { "name".allColsAfter(pathOf("firstName")) },
+            df.select { "name".allColsAfter(pathOf("name", "firstName")) },
+            df.select { Person::name.allColsAfter { firstNameAccessor } },
+            df.select { Person::name.allColsAfter(name.firstName) },
+            df.select { Person::name.allColsAfter(firstNameAccessor) },
+            df.select { Person::name.allColsAfter("firstName") },
+            df.select { Person::name.allColsAfter(Name::firstName) },
+            df.select { Person::name.allColsAfter(pathOf("firstName")) },
+            df.select { Person::name.allColsAfter(pathOf("name", "firstName")) },
+            df.select { NonDataSchemaPerson::name.allColsAfter { firstName } },
+            df.select { NonDataSchemaPerson::name.allColsAfter { firstNameAccessor } },
+            df.select { NonDataSchemaPerson::name.allColsAfter(name.firstName) },
+            df.select { NonDataSchemaPerson::name.allColsAfter(firstNameAccessor) },
+            df.select { NonDataSchemaPerson::name.allColsAfter("firstName") },
+            df.select { NonDataSchemaPerson::name.allColsAfter(Name::firstName) },
+            df.select { NonDataSchemaPerson::name.allColsAfter(pathOf("firstName")) },
+            df.select { NonDataSchemaPerson::name.allColsAfter(pathOf("name", "firstName")) },
+            df.select { pathOf("name").allColsAfter { firstNameAccessor } },
+            df.select { pathOf("name").allColsAfter(name.firstName) },
+            df.select { pathOf("name").allColsAfter(firstNameAccessor) },
+            df.select { pathOf("name").allColsAfter("firstName") },
+            df.select { pathOf("name").allColsAfter(Name::firstName) },
+            df.select { pathOf("name").allColsAfter(pathOf("firstName")) },
+            df.select { pathOf("name").allColsAfter(pathOf("name", "firstName")) },
+            df.select { name.allColsFrom { lastName } },
+            df.select { name.allColsFrom { lastNameAccessor } },
+            df.select { name.allColsFrom(name.lastName) },
+            df.select { name.allColsFrom(lastNameAccessor) },
+            df.select { name.allColsFrom("lastName") },
+            df.select { name.allColsFrom(Name::lastName) },
+            df.select { name.allColsFrom(pathOf("lastName")) },
+            df.select { name.allColsFrom(pathOf("name", "lastName")) },
+            df.select { "name".allColsFrom { lastNameAccessor } },
+            df.select { "name".allColsFrom(name.lastName) },
+            df.select { "name".allColsFrom(lastNameAccessor) },
+            df.select { "name".allColsFrom("lastName") },
+            df.select { "name".allColsFrom(Name::lastName) },
+            df.select { "name".allColsFrom(pathOf("lastName")) },
+            df.select { "name".allColsFrom(pathOf("name", "lastName")) },
+            df.select { Person::name.allColsFrom { lastNameAccessor } },
+            df.select { Person::name.allColsFrom(name.lastName) },
+            df.select { Person::name.allColsFrom(lastNameAccessor) },
+            df.select { Person::name.allColsFrom("lastName") },
+            df.select { Person::name.allColsFrom(Name::lastName) },
+            df.select { Person::name.allColsFrom(pathOf("lastName")) },
+            df.select { Person::name.allColsFrom(pathOf("name", "lastName")) },
+            df.select { NonDataSchemaPerson::name.allColsFrom { lastName } },
+            df.select { NonDataSchemaPerson::name.allColsFrom { lastNameAccessor } },
+            df.select { NonDataSchemaPerson::name.allColsFrom(name.lastName) },
+            df.select { NonDataSchemaPerson::name.allColsFrom(lastNameAccessor) },
+            df.select { NonDataSchemaPerson::name.allColsFrom("lastName") },
+            df.select { NonDataSchemaPerson::name.allColsFrom(Name::lastName) },
+            df.select { NonDataSchemaPerson::name.allColsFrom(pathOf("lastName")) },
+            df.select { NonDataSchemaPerson::name.allColsFrom(pathOf("name", "lastName")) },
+            df.select { pathOf("name").allColsFrom { lastNameAccessor } },
+            df.select { pathOf("name").allColsFrom(name.lastName) },
+            df.select { pathOf("name").allColsFrom(lastNameAccessor) },
+            df.select { pathOf("name").allColsFrom("lastName") },
+            df.select { pathOf("name").allColsFrom(Name::lastName) },
+            df.select { pathOf("name").allColsFrom(pathOf("lastName")) },
+            df.select { pathOf("name").allColsFrom(pathOf("name", "lastName")) },
+        ).shouldAllBeEqual()
+    }
+
+    @Suppress("CANDIDATE_CHOSEN_USING_OVERLOAD_RESOLUTION_BY_LAMBDA_ANNOTATION")
+    @Test
+    fun `all subset at lower level before and upTo`() {
+        val firstNameAccessor = column<String>("firstName")
+        val lastNameAccessor = column<String>("lastName")
+
+        listOf(
+            df.select { name.firstName },
+            df.select { name.allColsBefore { lastName } },
+            df.select { name.allColsBefore { lastNameAccessor } },
+            df.select { name.allColsBefore(name.lastName) }, // full path
+            df.select { name.allColsBefore(lastNameAccessor) },
+            df.select { name.allColsBefore("lastName") },
+            df.select { name.allColsBefore(Name::lastName) },
+            df.select { name.allColsBefore(pathOf("lastName")) },
+            df.select { name.allColsBefore(pathOf("name", "lastName")) }, // full path
+            df.select { "name".allColsBefore { lastNameAccessor } },
+            df.select { "name".allColsBefore(name.lastName) },
+            df.select { "name".allColsBefore(lastNameAccessor) },
+            df.select { "name".allColsBefore("lastName") },
+            df.select { "name".allColsBefore(Name::lastName) },
+            df.select { "name".allColsBefore(pathOf("lastName")) },
+            df.select { "name".allColsBefore(pathOf("name", "lastName")) },
+            df.select { Person::name.allColsBefore { lastNameAccessor } },
+            df.select { Person::name.allColsBefore(name.lastName) },
+            df.select { Person::name.allColsBefore(lastNameAccessor) },
+            df.select { Person::name.allColsBefore("lastName") },
+            df.select { Person::name.allColsBefore(Name::lastName) },
+            df.select { Person::name.allColsBefore(pathOf("lastName")) },
+            df.select { Person::name.allColsBefore(pathOf("name", "lastName")) },
+            df.select { NonDataSchemaPerson::name.allColsBefore { lastName } },
+            df.select { NonDataSchemaPerson::name.allColsBefore { lastNameAccessor } },
+            df.select { NonDataSchemaPerson::name.allColsBefore(name.lastName) },
+            df.select { NonDataSchemaPerson::name.allColsBefore(lastNameAccessor) },
+            df.select { NonDataSchemaPerson::name.allColsBefore("lastName") },
+            df.select { NonDataSchemaPerson::name.allColsBefore(Name::lastName) },
+            df.select { NonDataSchemaPerson::name.allColsBefore(pathOf("lastName")) },
+            df.select { NonDataSchemaPerson::name.allColsBefore(pathOf("name", "lastName")) },
+            df.select { pathOf("name").allColsBefore { lastNameAccessor } },
+            df.select { pathOf("name").allColsBefore(name.lastName) },
+            df.select { pathOf("name").allColsBefore(lastNameAccessor) },
+            df.select { pathOf("name").allColsBefore("lastName") },
+            df.select { pathOf("name").allColsBefore(Name::lastName) },
+            df.select { pathOf("name").allColsBefore(pathOf("lastName")) },
+            df.select { pathOf("name").allColsBefore(pathOf("name", "lastName")) },
+            df.select { name.allColsUpTo { firstName } },
+            df.select { name.allColsUpTo { firstNameAccessor } },
+            df.select { name.allColsUpTo(name.firstName) },
+            df.select { name.allColsUpTo(firstNameAccessor) },
+            df.select { name.allColsUpTo("firstName") },
+            df.select { name.allColsUpTo(Name::firstName) },
+            df.select { name.allColsUpTo(pathOf("firstName")) },
+            df.select { name.allColsUpTo(pathOf("name", "firstName")) },
+            df.select { "name".allColsUpTo { firstNameAccessor } },
+            df.select { "name".allColsUpTo(name.firstName) },
+            df.select { "name".allColsUpTo(firstNameAccessor) },
+            df.select { "name".allColsUpTo("firstName") },
+            df.select { "name".allColsUpTo(Name::firstName) },
+            df.select { "name".allColsUpTo(pathOf("firstName")) },
+            df.select { "name".allColsUpTo(pathOf("name", "firstName")) },
+            df.select { Person::name.allColsUpTo { firstNameAccessor } },
+            df.select { Person::name.allColsUpTo(name.firstName) },
+            df.select { Person::name.allColsUpTo(firstNameAccessor) },
+            df.select { Person::name.allColsUpTo("firstName") },
+            df.select { Person::name.allColsUpTo(Name::firstName) },
+            df.select { Person::name.allColsUpTo(pathOf("firstName")) },
+            df.select { Person::name.allColsUpTo(pathOf("name", "firstName")) },
+            df.select { NonDataSchemaPerson::name.allColsUpTo { firstName } },
+            df.select { NonDataSchemaPerson::name.allColsUpTo { firstNameAccessor } },
+            df.select { NonDataSchemaPerson::name.allColsUpTo(name.firstName) },
+            df.select { NonDataSchemaPerson::name.allColsUpTo(firstNameAccessor) },
+            df.select { NonDataSchemaPerson::name.allColsUpTo("firstName") },
+            df.select { NonDataSchemaPerson::name.allColsUpTo(Name::firstName) },
+            df.select { NonDataSchemaPerson::name.allColsUpTo(pathOf("firstName")) },
+            df.select { NonDataSchemaPerson::name.allColsUpTo(pathOf("name", "firstName")) },
+            df.select { pathOf("name").allColsUpTo { firstNameAccessor } },
+            df.select { pathOf("name").allColsUpTo(name.firstName) },
+            df.select { pathOf("name").allColsUpTo(firstNameAccessor) },
+            df.select { pathOf("name").allColsUpTo("firstName") },
+            df.select { pathOf("name").allColsUpTo(Name::firstName) },
+            df.select { pathOf("name").allColsUpTo(pathOf("firstName")) },
+            df.select { pathOf("name").allColsUpTo(pathOf("name", "firstName")) },
+        ).shouldAllBeEqual()
+    }
+
+    @Test
+    fun `2 levels deep`() {
+        val secondNameAccessor = column<String?>("secondName")
+        val thirdNameAccessor = column<String?>("thirdName")
+        listOf(
+            dfGroup.select { name.firstName { firstName and secondName } },
+            dfGroup.select { name.firstName.allColsBefore { thirdName } },
+            dfGroup.select { name.firstName.allColsBefore { thirdNameAccessor } },
+            dfGroup.select { name.firstName.allColsBefore(name.firstName.thirdName) },
+            dfGroup.select { name.firstName.allColsBefore("thirdName") },
+            dfGroup.select { name.firstName.allColsBefore(FirstNames::thirdName) },
+            dfGroup.select { name.firstName.allColsBefore(thirdNameAccessor) },
+            dfGroup.select { name.firstName.allColsBefore(pathOf("thirdName")) },
+            dfGroup.select { name.firstName.allColsBefore(pathOf("name", "firstName", "thirdName")) },
+            dfGroup.select { name.firstName.allColsUpTo { secondName } },
+            dfGroup.select { name.firstName.allColsUpTo { secondNameAccessor } },
+            dfGroup.select { name.firstName.allColsUpTo(name.firstName.secondName) },
+            dfGroup.select { name.firstName.allColsUpTo("secondName") },
+            dfGroup.select { name.firstName.allColsUpTo(FirstNames::secondName) },
+            dfGroup.select { name.firstName.allColsUpTo(secondNameAccessor) },
+            dfGroup.select { name.firstName.allColsUpTo(pathOf("secondName")) },
+            dfGroup.select { name.firstName.allColsUpTo(pathOf("name", "firstName", "secondName")) },
+        ).shouldAllBeEqual()
+    }
+
+    @Test
+    fun `ambiguous cases`() {
+        @Language("json")
+        val json =
+            """
+            {
+                 "a": {
+                     "a": 1,
+                     "b": 2
+                 }
+            }
+            """.trimIndent()
+
+        val df = DataFrame.readJsonStr(json).alsoDebug()
+
+        listOf(
+            df.select { "a"["b"] }.alsoDebug(),
+            df.select { "a".allColsAfter("a") },
+            df.select { "a".allColsAfter("a"["a"]) },
+        ).shouldAllBeEqual()
+    }
+}
diff --git a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/allExcept.kt b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/allExcept.kt
new file mode 100644
index 000000000..58ef04245
--- /dev/null
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/allExcept.kt
@@ -0,0 +1,385 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import io.kotest.assertions.throwables.shouldThrow
+import io.kotest.matchers.shouldBe
+import org.jetbrains.kotlinx.dataframe.alsoDebug
+import org.jetbrains.kotlinx.dataframe.samples.api.age
+import org.jetbrains.kotlinx.dataframe.samples.api.city
+import org.jetbrains.kotlinx.dataframe.samples.api.firstName
+import org.jetbrains.kotlinx.dataframe.samples.api.isHappy
+import org.jetbrains.kotlinx.dataframe.samples.api.lastName
+import org.jetbrains.kotlinx.dataframe.samples.api.name
+import org.jetbrains.kotlinx.dataframe.samples.api.secondName
+import org.jetbrains.kotlinx.dataframe.samples.api.thirdName
+import org.jetbrains.kotlinx.dataframe.samples.api.weight
+import org.junit.Test
+
+class AllExceptTests : ColumnsSelectionDslTests() {
+
+    @Test
+    fun `exceptions`() {
+        shouldThrow<IllegalStateException> {
+            dfGroup.select {
+                name.firstName.allColsExcept("firstName"["secondName"])
+            }
+        }
+
+        shouldThrow<IllegalStateException> {
+            dfGroup.select {
+                name.firstName.allColsExcept(pathOf("name", "firstName", "secondName"))
+            }
+        }
+    }
+
+    @Test
+    fun `empty group`() {
+        df.select { name.allColsExcept { all() } } shouldBe df.select { none() }
+
+        df.select { allExcept { all() } } shouldBe df.select { none() }
+
+        df.select { allExcept { name.allCols() } }.alsoDebug()
+
+        df.remove { name.allCols() }.alsoDebug()
+    }
+
+    @Test
+    fun `top-level`() {
+        listOf(
+            df.select { cols(age, weight, isHappy) },
+            df.select { allExcept { name and city } },
+            df.select { allExcept(name and city) }, // legacy, but does no harm, so supported
+            df.select { allExcept { cols { it.name in listOf("name", "city") } } },
+            df.select { allExcept("name", "city") },
+            df.select { allExcept(Person::name, Person::city) },
+            df.select { allExcept(pathOf("name"), pathOf("city")) },
+        ).shouldAllBeEqual()
+
+        listOf(
+            df.select { cols(age, city, weight, isHappy) },
+            df.select { allExcept { name } },
+            df.select { allExcept(name) }, // legacy, but does no harm, so supported
+            df.select { allExcept { cols { it.name == "name" } } },
+            df.select { allExcept("name") },
+            df.select { allExcept(Person::name) },
+            df.select { allExcept(pathOf("name")) },
+        ).shouldAllBeEqual()
+
+        listOf(
+            df.select { all() },
+            df.select { allExcept { none() } },
+        ).shouldAllBeEqual()
+
+        listOf(
+            df.select { name and name.firstName }.alsoDebug(),
+        ).shouldAllBeEqual()
+
+        df.select { (name and name.firstName and name.firstName) except name.firstName }.alsoDebug()
+
+        df.select { (name and name and name.firstName) except name.firstName }.alsoDebug()
+    }
+
+    @Test
+    fun `on columnSet`() {
+        val cityAccessor = column<String?>("city")
+        val nameAccessor = column<String>("name")
+        listOf(
+            df.select { cols(age, weight, isHappy) },
+            df.select { cols().except { cols { it.name in listOf("name", "city") } } },
+            df.select { cols().except { cityAccessor and nameAccessor } },
+            df.select { cols().except { city and name } },
+            df.select { cols().except(city and name) },
+            df.select { cols().except(city, name) },
+            df.select { cols().except(cityAccessor, nameAccessor) },
+            df.select { cols().except("city", "name") },
+            df.select { cols().except(Person::city, Person::name) },
+            df.select { cols().except(pathOf("city"), pathOf("name")) },
+        ).shouldAllBeEqual()
+
+        listOf(
+            df.select { cols(age, city, weight, isHappy) },
+            df.select { cols() except { cols { it.name == "name" } } },
+            df.select { cols() except cols { it.name == "name" } },
+            df.select { cols() except nameAccessor },
+            df.select { cols() except name },
+            df.select { cols() except "name" },
+            df.select { cols() except Person::name },
+            df.select { cols() except pathOf("name") },
+        ).shouldAllBeEqual()
+
+        listOf(
+            df.select { all() },
+            df.select { all() except { none() } },
+            df.select { all() except none() },
+        ).shouldAllBeEqual()
+
+        // might not work as expected, use colsAtAnyDepth instead
+        df.select { name.allCols() except { cols { "last" in it.name } } }
+        df.select { name.allCols() except cols { "last" in it.name } }
+        // or, you know
+        df.select { name.cols { "last" !in it.name } }
+
+        listOf(
+            df.select { name.firstName },
+            df.select { name.allCols() except { colsAtAnyDepth { "last" in it.name } } },
+            df.select { name.allCols() except colsAtAnyDepth { "last" in it.name } },
+            df.select { name.allCols() except { name.lastName } },
+            df.select { name.allCols() except name.lastName },
+            df.select { name.allCols() except { colGroup("name").col("lastName") } },
+            df.select { name.allCols() except colGroup("name").col("lastName") },
+            df.select { name.allCols() except { "name"["lastName"] } },
+            df.select { name.allCols() except "name"["lastName"] },
+        ).shouldAllBeEqual()
+
+        listOf(
+            df.select { name.allCols() },
+            df.select { name.allCols() except { none() } },
+            df.select { name.allCols() except none() },
+        ).shouldAllBeEqual()
+    }
+
+    @Test
+    fun `on lower level`() {
+        val lastNameAccessor = column<String>("lastName")
+        listOf(
+            df.select { name.firstName },
+            df.select { name.allColsExcept { lastName } },
+            df.select { name.allColsExcept { lastNameAccessor } },
+//            df.select { name.allColsExcept(name.lastName) }, // blocked
+//            df.select { name.allColsExcept(lastNameAccessor) }, // blocked
+            df.select { name.allColsExcept("lastName") },
+            df.select { name.allColsExcept("lastName", "lastName") },
+            df.select { name.allColsExcept(Name::lastName) },
+            df.select { name.allColsExcept(Name::lastName, Name::lastName) },
+            df.select { name.allColsExcept(pathOf("lastName")) },
+            df.select { name.allColsExcept(pathOf("lastName"), pathOf("lastName")) },
+//            df.select { name.allColsExcept(pathOf("name", "lastName")) }, // breaks
+            df.select { name.allColsExcept { cols { "last" in it.name } } },
+            df.select { "name".allColsExcept { lastNameAccessor } },
+//            df.select { "name".allColsExcept(name.lastName) }, // blocked
+//            df.select { "name".allColsExcept(lastNameAccessor) }, // blocked
+            df.select { "name".allColsExcept("lastName") },
+            df.select { "name".allColsExcept("lastName", "lastName") },
+            df.select { "name".allColsExcept(Name::lastName) },
+            df.select { "name".allColsExcept(Name::lastName, Name::lastName) },
+            df.select { "name".allColsExcept(pathOf("lastName")) },
+            df.select { "name".allColsExcept(pathOf("lastName"), pathOf("lastName")) },
+//            df.select { "name".allColsExcept(pathOf("name", "lastName")) }, // breaks
+            df.select { "name".allColsExcept { cols { "last" in it.name } } },
+//            df.select { Person::name.allColsExcept(name.lastName) }, // blocked
+//            df.select { Person::name.allColsExcept(lastNameAccessor) }, // blocked
+            df.select { Person::name.allColsExcept("lastName") },
+            df.select { Person::name.allColsExcept("lastName", "lastName") },
+            df.select { Person::name.allColsExcept(Name::lastName) },
+            df.select { Person::name.allColsExcept(Name::lastName, Name::lastName) },
+            df.select { Person::name.allColsExcept(pathOf("lastName")) },
+            df.select { Person::name.allColsExcept(pathOf("lastName"), pathOf("lastName")) },
+//            df.select { Person::name.allColsExcept(pathOf("name", "lastName")) }, // breaks
+            df.select { Person::name.allColsExcept { cols { "last" in it.name } } },
+            df.select { NonDataSchemaPerson::name.allColsExcept { lastName } },
+            df.select { NonDataSchemaPerson::name.allColsExcept { lastNameAccessor } },
+//            df.select { NonDataSchemaPerson::name.allColsExcept(name.lastName) }, // blocked
+//            df.select { NonDataSchemaPerson::name.allColsExcept(lastNameAccessor) }, // blocked
+            df.select { NonDataSchemaPerson::name.allColsExcept("lastName") },
+            df.select { NonDataSchemaPerson::name.allColsExcept("lastName", "lastName") },
+            df.select { NonDataSchemaPerson::name.allColsExcept(Name::lastName) },
+            df.select { NonDataSchemaPerson::name.allColsExcept(Name::lastName, Name::lastName) },
+            df.select { NonDataSchemaPerson::name.allColsExcept(pathOf("lastName")) },
+            df.select { NonDataSchemaPerson::name.allColsExcept(pathOf("lastName"), pathOf("lastName")) },
+//            df.select { NonDataSchemaPerson::name.allColsExcept(pathOf("name", "lastName")) }, // breaks
+            df.select { NonDataSchemaPerson::name.allColsExcept { cols { "last" in it.name } } },
+            df.select { pathOf("name").allColsExcept { lastNameAccessor } },
+//            df.select { pathOf("name").allColsExcept(name.lastName) }, // blocked
+//            df.select { pathOf("name").allColsExcept(lastNameAccessor) }, // blocked
+            df.select { pathOf("name").allColsExcept("lastName") },
+            df.select { pathOf("name").allColsExcept("lastName", "lastName") },
+            df.select { pathOf("name").allColsExcept(Name::lastName) },
+            df.select { pathOf("name").allColsExcept(Name::lastName, Name::lastName) },
+            df.select { pathOf("name").allColsExcept(pathOf("lastName")) },
+            df.select { pathOf("name").allColsExcept(pathOf("lastName"), pathOf("lastName")) },
+//            df.select { pathOf("name").allColsExcept(pathOf("name", "lastName")) }, // breaks
+            df.select { pathOf("name").allColsExcept { cols { "last" in it.name } } },
+        ).shouldAllBeEqual()
+    }
+
+    @Test
+    fun `2 levels deep`() {
+        listOf(
+            dfGroup.remove { name.firstName.secondName }.select { name.allCols() }.alsoDebug(),
+            dfGroup.select {
+                name.allColsExcept("firstName"["secondName"])
+            },
+            dfGroup.select {
+                name.allColsExcept { firstName.secondName and firstName.secondName }
+            },
+            dfGroup.select {
+                name.allColsExcept { colGroup("firstName").col("secondName") }
+            },
+        ).shouldAllBeEqual()
+
+        listOf(
+            dfGroup.remove { name.firstName.secondName }.select { name.firstName.allCols() }.alsoDebug(),
+            dfGroup.select {
+                name.firstName.allColsExcept("secondName")
+            },
+            dfGroup.select {
+                name.firstName.allColsExcept { secondName }
+            },
+            dfGroup.select {
+                name.firstName.allColsExcept(pathOf("secondName"))
+            },
+        ).shouldAllBeEqual()
+
+        listOf(
+            dfGroup.select { name.firstName { secondName and thirdName } },
+            dfGroup.select { name { firstName.allColsExcept("firstName") } }.alsoDebug(),
+            dfGroup.select { name { firstName.allColsExcept(pathOf("firstName")) } }.alsoDebug(),
+            dfGroup.select { (name.allColsExcept("firstName"["firstName"])).first().asColumnGroup().allCols() },
+            dfGroup.remove { name.firstName.firstName }.select { name.firstName.allCols() },
+        ).shouldAllBeEqual()
+
+        val secondNameAccessor = column<String?>("secondName")
+        val thirdNameAccessor = column<String?>("thirdName")
+
+        listOf(
+            dfGroup.select { name.firstName.firstName },
+            dfGroup.select { name.firstName.allColsExcept { secondName and thirdName } },
+            dfGroup.select { name.firstName.allColsExcept { secondNameAccessor and thirdNameAccessor } },
+            dfGroup.select { name.firstName.allColsExcept("secondName", "thirdName") },
+            dfGroup.select { name.firstName.allColsExcept(FirstNames::secondName, FirstNames::thirdName) },
+            dfGroup.select { name.firstName.allColsExcept(pathOf("secondName"), pathOf("thirdName")) },
+            dfGroup.select { name.firstName.allColsExcept { cols { it.name in listOf("secondName", "thirdName") } } },
+            dfGroup.select { name.firstName { allExcept { secondName and thirdName } } },
+            dfGroup.select { name.firstName { allExcept { secondNameAccessor and thirdNameAccessor } } },
+            dfGroup.select { name.firstName { allExcept("secondName", "thirdName") } },
+            dfGroup.select { name.firstName { allExcept(FirstNames::secondName, FirstNames::thirdName) } },
+            dfGroup.select { name.firstName { allExcept(pathOf("secondName"), pathOf("thirdName")) } },
+            dfGroup.select { name.firstName { allExcept { cols { it.name in listOf("secondName", "thirdName") } } } },
+            dfGroup.select { name { firstName.allColsExcept { secondName and thirdName } } },
+            dfGroup.select { name { firstName.allColsExcept { secondNameAccessor and thirdNameAccessor } } },
+            dfGroup.select { name { firstName.allColsExcept("secondName", "thirdName") } },
+            dfGroup.select { name { firstName.allColsExcept(FirstNames::secondName, FirstNames::thirdName) } },
+            dfGroup.select { name { firstName.allColsExcept(pathOf("secondName"), pathOf("thirdName")) } },
+            dfGroup.select {
+                name {
+                    firstName.allColsExcept {
+                        cols { it.name in listOf("secondName", "thirdName") }
+                    }
+                }
+            },
+            dfGroup.select { name { firstName { allExcept { secondName and thirdName } } } },
+            dfGroup.select { name { firstName { allExcept { secondNameAccessor and thirdNameAccessor } } } },
+            dfGroup.select { name { firstName { allExcept("secondName", "thirdName") } } },
+            dfGroup.select { name { firstName { allExcept(FirstNames::secondName, FirstNames::thirdName) } } },
+            dfGroup.select { name { firstName { allExcept(pathOf("secondName"), pathOf("thirdName")) } } },
+            dfGroup.select {
+                name {
+                    firstName {
+                        allExcept {
+                            cols { it.name in listOf("secondName", "thirdName") }
+                        }
+                    }
+                }
+            },
+        ).shouldAllBeEqual()
+    }
+
+    @OptIn(ExperimentalExceptCsDsl::class)
+    @Test
+    fun `except experiments`() {
+        val firstNameAccessor = column<String>("firstName")
+        listOf(
+            df.select { name }.remove { name.firstName }.alsoDebug(),
+            df.select { cols(name) except name.firstName },
+            df.select { name exceptNew { cols { "first" in it.name } } },
+            df.select { name.exceptNew { cols { "first" in it.name } and cols { "first" in it.name } } },
+            df.select { name exceptNew { firstName } },
+            df.select { name.exceptNew { firstNameAccessor } },
+            df.select { name exceptNew { firstName and firstName } },
+            df.select { name.exceptNew { firstNameAccessor and firstNameAccessor } },
+//            df.select { name exceptNew name.firstName }, // not allowed
+//            df.select { name.exceptNew(name.firstName and name.firstName) }, // not allowed
+//            df.select { name exceptNew firstNameAccessor }, // not allowed
+//            df.select { name.exceptNew(firstNameAccessor and firstNameAccessor) }, // not allowed
+            df.select { name exceptNew "firstName" },
+            df.select { name.exceptNew("firstName") },
+            df.select { name.exceptNew("firstName", "firstName") },
+            df.select { name exceptNew Name::firstName },
+            df.select { name.exceptNew(Name::firstName) },
+            df.select { name.exceptNew(Name::firstName, Name::firstName) },
+            df.select { name exceptNew pathOf("firstName") },
+            df.select { name.exceptNew(pathOf("firstName")) },
+            df.select { name.exceptNew(pathOf("firstName"), pathOf("firstName")) },
+            df.select { "name" exceptNew { cols { "first" in it.name } } },
+            df.select { "name".exceptNew { cols { "first" in it.name } and cols { "first" in it.name } } },
+            df.select { "name".exceptNew { firstNameAccessor } },
+            df.select { "name".exceptNew { firstNameAccessor and firstNameAccessor } },
+//            df.select { "name" exceptNew name.firstName }, // not allowed
+//            df.select { "name".exceptNew(name.firstName and name.firstName) }, // not allowed
+//            df.select { "name" exceptNew firstNameAccessor }, // not allowed
+//            df.select { "name".exceptNew(firstNameAccessor and firstNameAccessor) }, // not allowed
+            df.select { "name" exceptNew "firstName" },
+            df.select { "name".exceptNew("firstName") },
+            df.select { "name".exceptNew("firstName", "firstName") },
+            df.select { "name" exceptNew Name::firstName },
+            df.select { "name".exceptNew(Name::firstName) },
+            df.select { "name".exceptNew(Name::firstName, Name::firstName) },
+            df.select { "name" exceptNew pathOf("firstName") },
+            df.select { "name".exceptNew(pathOf("firstName")) },
+            df.select { "name".exceptNew(pathOf("firstName"), pathOf("firstName")) },
+//            df.select { Person::name exceptNew name.firstName }, // not allowed
+//            df.select { Person::name.exceptNew(name.firstName and name.firstName) }, // not allowed
+//            df.select { Person::name exceptNew firstNameAccessor }, // not allowed
+//            df.select { Person::name.exceptNew(firstNameAccessor and firstNameAccessor) }, // not allowed
+            df.select { Person::name exceptNew "firstName" },
+            df.select { Person::name.exceptNew("firstName") },
+            df.select { Person::name.exceptNew("firstName", "firstName") },
+            df.select { Person::name exceptNew Name::firstName },
+            df.select { Person::name.exceptNew(Name::firstName) },
+            df.select { Person::name.exceptNew(Name::firstName, Name::firstName) },
+            df.select { Person::name exceptNew pathOf("firstName") },
+            df.select { Person::name.exceptNew(pathOf("firstName")) },
+            df.select { Person::name.exceptNew(pathOf("firstName"), pathOf("firstName")) },
+            df.select { NonDataSchemaPerson::name exceptNew { cols { "first" in it.name } } },
+            df.select {
+                NonDataSchemaPerson::name.exceptNew {
+                    cols { "first" in it.name } and
+                        cols { "first" in it.name }
+                }
+            },
+            df.select { NonDataSchemaPerson::name exceptNew { firstName } },
+            df.select { NonDataSchemaPerson::name.exceptNew { firstNameAccessor } },
+            df.select { NonDataSchemaPerson::name exceptNew { firstName and firstName } },
+            df.select { NonDataSchemaPerson::name.exceptNew { firstNameAccessor and firstNameAccessor } },
+//            df.select { NonDataSchemaPerson::name exceptNew name.firstName }, // not allowed
+//            df.select { NonDataSchemaPerson::name.exceptNew(name.firstName and name.firstName) }, // not allowed
+//            df.select { NonDataSchemaPerson::name exceptNew firstNameAccessor }, // not allowed
+//            df.select { NonDataSchemaPerson::name.exceptNew(firstNameAccessor and firstNameAccessor) }, // not allowed
+            df.select { NonDataSchemaPerson::name exceptNew "firstName" },
+            df.select { NonDataSchemaPerson::name.exceptNew("firstName") },
+            df.select { NonDataSchemaPerson::name.exceptNew("firstName", "firstName") },
+            df.select { NonDataSchemaPerson::name exceptNew Name::firstName },
+            df.select { NonDataSchemaPerson::name.exceptNew(Name::firstName) },
+            df.select { NonDataSchemaPerson::name.exceptNew(Name::firstName, Name::firstName) },
+            df.select { NonDataSchemaPerson::name exceptNew pathOf("firstName") },
+            df.select { NonDataSchemaPerson::name.exceptNew(pathOf("firstName")) },
+            df.select { NonDataSchemaPerson::name.exceptNew(pathOf("firstName"), pathOf("firstName")) },
+            df.select { pathOf("name") exceptNew { cols { "first" in it.name } } },
+            df.select { pathOf("name").exceptNew { cols { "first" in it.name } and cols { "first" in it.name } } },
+            df.select { pathOf("name").exceptNew { firstNameAccessor } },
+            df.select { pathOf("name").exceptNew { firstNameAccessor and firstNameAccessor } },
+//            df.select { pathOf("name") exceptNew name.firstName }, // not allowed
+//            df.select { pathOf("name").exceptNew(name.firstName and name.firstName) }, // not allowed
+//            df.select { pathOf("name") exceptNew firstNameAccessor }, // not allowed
+//            df.select { pathOf("name").exceptNew(firstNameAccessor and firstNameAccessor) }, // not allowed
+            df.select { pathOf("name") exceptNew "firstName" },
+            df.select { pathOf("name").exceptNew("firstName") },
+            df.select { pathOf("name").exceptNew("firstName", "firstName") },
+            df.select { pathOf("name") exceptNew Name::firstName },
+            df.select { pathOf("name").exceptNew(Name::firstName) },
+            df.select { pathOf("name").exceptNew(Name::firstName, Name::firstName) },
+            df.select { pathOf("name") exceptNew pathOf("firstName") },
+            df.select { pathOf("name").exceptNew(pathOf("firstName")) },
+            df.select { pathOf("name").exceptNew(pathOf("firstName"), pathOf("firstName")) },
+        ).shouldAllBeEqual()
+    }
+}
diff --git a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/and.kt b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/and.kt
new file mode 100644
index 000000000..45238c2c2
--- /dev/null
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/and.kt
@@ -0,0 +1,141 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import org.jetbrains.kotlinx.dataframe.ColumnsSelector
+import org.jetbrains.kotlinx.dataframe.samples.api.age
+import org.jetbrains.kotlinx.dataframe.samples.api.name
+import org.jetbrains.kotlinx.dataframe.samples.api.weight
+import org.junit.Test
+
+class AndTests : ColumnsSelectionDslTests() {
+
+    @Test
+    fun `and 2`() {
+        val ageSelector: ColumnsSelector<Person, Int> = { age }
+        listOf(
+            df.select { cols(age, name) },
+            df.select { age and name },
+            df.select { age and "name" },
+            df.select { age and Person::name },
+            df.select { age and pathOf("name") },
+            df.select { age and cols(name) },
+            df.select { age.and(name) },
+            df.select { age.and("name") },
+            df.select { age.and(Person::name) },
+            df.select { age.and(pathOf("name")) },
+            df.select { age.and(cols(name)) },
+            df.select { age and { name } },
+            df.select { age and { "name"<String>() } },
+            df.select { age and { (Person::name)() } },
+            df.select { age and { pathOf("name") } },
+            df.select { age and { cols(name) } },
+            df.select { age.and { name } },
+            df.select { "age" and name },
+            df.select { "age" and "name" },
+            df.select { "age" and Person::name },
+            df.select { "age" and pathOf("name") },
+            df.select { "age" and cols(name) },
+            df.select { "age".and(name) },
+            df.select { "age".and("name") },
+            df.select { "age".and(Person::name) },
+            df.select { "age".and(pathOf("name")) },
+            df.select { "age".and(cols(name)) },
+            df.select { "age" and { name } },
+            df.select { "age" and { "name"<String>() } },
+            df.select { "age" and { (Person::name)() } },
+            df.select { "age" and { pathOf("name") } },
+            df.select { "age" and { cols(name) } },
+            df.select { "age".and { name } },
+            df.select { Person::age and name },
+            df.select { Person::age and "name" },
+            df.select { Person::age and Person::name },
+            df.select { Person::age and pathOf("name") },
+            df.select { Person::age and cols(name) },
+            df.select { Person::age.and(name) },
+            df.select { Person::age.and("name") },
+            df.select { Person::age.and(Person::name) },
+            df.select { Person::age.and(pathOf("name")) },
+            df.select { Person::age.and(cols(name)) },
+            df.select { Person::age and { name } },
+            df.select { Person::age and { "name"<String>() } },
+            df.select { Person::age and { (Person::name)() } },
+            df.select { Person::age and { pathOf("name") } },
+            df.select { Person::age and { cols(name) } },
+            df.select { Person::age.and { name } },
+            df.select { pathOf("age") and name },
+            df.select { pathOf("age") and "name" },
+            df.select { pathOf("age") and Person::name },
+            df.select { pathOf("age") and pathOf("name") },
+            df.select { pathOf("age") and cols(name) },
+            df.select { pathOf("age").and(name) },
+            df.select { pathOf("age").and("name") },
+            df.select { pathOf("age").and(Person::name) },
+            df.select { pathOf("age").and(pathOf("name")) },
+            df.select { pathOf("age").and(cols(name)) },
+            df.select { pathOf("age") and { name } },
+            df.select { pathOf("age") and { "name"<String>() } },
+            df.select { pathOf("age") and { (Person::name)() } },
+            df.select { pathOf("age") and { pathOf("name") } },
+            df.select { pathOf("age") and { cols(name) } },
+            df.select { pathOf("age").and { name } },
+            df.select { ageSelector() and name },
+            df.select { ageSelector() and name },
+            df.select { ageSelector() and "name" },
+            df.select { ageSelector() and Person::name },
+            df.select { ageSelector() and pathOf("name") },
+            df.select { ageSelector() and cols(name) },
+            df.select { ageSelector().and(name) },
+            df.select { ageSelector().and("name") },
+            df.select { ageSelector().and(Person::name) },
+            df.select { ageSelector().and(pathOf("name")) },
+            df.select { ageSelector().and(cols(name)) },
+            df.select { ageSelector() and { name } },
+            df.select { ageSelector() and { "name"<String>() } },
+            df.select { ageSelector() and { (Person::name)() } },
+            df.select { ageSelector() and { pathOf("name") } },
+            df.select { ageSelector() and { cols(name) } },
+            df.select { ageSelector().and { name } },
+        ).shouldAllBeEqual()
+    }
+
+    @Test
+    fun `and 3`() {
+        listOf(
+            df.select { cols(age, name, weight) },
+            df.select { age and name and weight },
+            df.select { age and "name" and weight },
+            df.select { age and Person::name and weight },
+            df.select { age and pathOf("name") and weight },
+            df.select { age and cols(name) and weight },
+            df.select { age.and(name).and(weight) },
+            df.select { age.and("name").and(weight) },
+            df.select { age.and(Person::name).and(weight) },
+            df.select { age.and(pathOf("name")).and(weight) },
+            df.select { age.and(cols(name)).and(weight) },
+            df.select { age.and(name and weight) },
+            df.select { age.and("name" and weight) },
+            df.select { age.and(Person::name and weight) },
+            df.select { age.and(pathOf("name") and weight) },
+            df.select { age.and(cols(name) and weight) },
+            df.select { age.and(name).and("weight") },
+            df.select { age.and("name").and("weight") },
+            df.select { age.and(Person::name).and("weight") },
+            df.select { age.and(pathOf("name")).and("weight") },
+            df.select { age.and(cols(name)).and("weight") },
+            df.select { age.and(name and "weight") },
+            df.select { age.and("name" and "weight") },
+            df.select { age.and(Person::name and "weight") },
+            df.select { age.and(pathOf("name") and "weight") },
+            df.select { age.and(cols(name) and "weight") },
+            df.select { age.and(name).and(Person::weight) },
+            df.select { age.and("name").and(Person::weight) },
+            df.select { age.and(Person::name).and(Person::weight) },
+            df.select { age.and(pathOf("name")).and(Person::weight) },
+            df.select { age.and(cols(name)).and(Person::weight) },
+            df.select { age.and(name and Person::weight) },
+            df.select { age.and("name" and Person::weight) },
+            df.select { age.and(Person::name and Person::weight) },
+            df.select { age.and(pathOf("name") and Person::weight) },
+            df.select { age.and(cols(name) and Person::weight) },
+        ).shouldAllBeEqual()
+    }
+}
diff --git a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/cast.kt b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/cast.kt
new file mode 100644
index 000000000..025a68bbd
--- /dev/null
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/cast.kt
@@ -0,0 +1,26 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import io.kotest.assertions.throwables.shouldThrow
+import io.kotest.matchers.shouldBe
+import org.jetbrains.kotlinx.dataframe.annotations.DataSchema
+import org.junit.Test
+import java.lang.IllegalArgumentException
+
+class CastTests {
+
+    @Test
+    fun safeUnsafeCast() {
+        @DataSchema
+        data class Data(val a: Int, val b: String)
+
+        val df = dataFrameOf("a", "b", "c")(1, "s", 2)
+        df.cast<Data>(verify = true) shouldBe df
+
+        shouldThrow<IllegalArgumentException> {
+            df.convert("a").toDouble().cast<Data>(verify = true)
+        }
+        val converted = df.convert("a").toDouble()
+        converted.cast<Data>(verify = false) shouldBe converted
+        converted.cast<Data>() shouldBe converted
+    }
+}
diff --git a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/chunked.kt b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/chunked.kt
new file mode 100644
index 000000000..fd98ad8f3
--- /dev/null
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/chunked.kt
@@ -0,0 +1,17 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import io.kotest.matchers.shouldBe
+import org.jetbrains.kotlinx.dataframe.size
+import org.junit.Test
+
+class ChunkedTests {
+
+    @Test
+    fun chunkedColumnGroup() {
+        val a by columnOf(listOf(1, 2, 3).toColumn("b"), listOf(4, 5, 6).toColumn("c"))
+        val chunked = a.asColumnGroup().chunked(2)
+        chunked.size shouldBe 2
+        chunked.name() shouldBe "a"
+        chunked[1].rowsCount() shouldBe 1
+    }
+}
diff --git a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/col.kt b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/col.kt
new file mode 100644
index 000000000..25cc6c27e
--- /dev/null
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/col.kt
@@ -0,0 +1,118 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import io.kotest.assertions.throwables.shouldThrow
+import org.jetbrains.kotlinx.dataframe.alsoDebug
+import org.jetbrains.kotlinx.dataframe.samples.api.age
+import org.jetbrains.kotlinx.dataframe.samples.api.firstName
+import org.jetbrains.kotlinx.dataframe.samples.api.name
+import org.junit.Test
+
+class ColTests : ColumnsSelectionDslTests() {
+
+    @Test
+    fun `col on renamed column`() {
+        df
+            .select { colGroup("name").named("name1").col("firstName") }
+            .alsoDebug()
+    }
+
+    @Test
+    fun `col exceptions`() {
+        shouldThrow<IllegalStateException> {
+            df.select { col("nonExisting") }
+        }
+        shouldThrow<IllegalStateException> {
+            df.select { name.col("nonExisting") }
+        }
+        shouldThrow<IllegalStateException> {
+            df.select { "age".col("test") }
+        }
+        shouldThrow<IndexOutOfBoundsException> {
+            df.select { col(100) }
+        }
+    }
+
+    @Test
+    fun `col at top-level`() {
+        val ageAccessor = column<Int>("age")
+        listOf(
+            df.select { age },
+            @Suppress("DEPRECATION")
+            df.select { col(ageAccessor) },
+            df.select { col("age") },
+            df.select { col<Int>("age") },
+            df.select { col(pathOf("age")) },
+            df.select { col<Int>(pathOf("age")) },
+            df.select { col(Person::age) },
+            df.select { all().col(1) },
+            df.select { all()[1] },
+            df.select { col(1) },
+            df.select { col<Int>(1) },
+        ).shouldAllBeEqual()
+    }
+
+    @Test
+    fun `col at lower level`() {
+        val firstNameAccessor = column<String>("firstName")
+        listOf(
+            df.select { name.firstName },
+            // reference
+            df.select { name.col(firstNameAccessor) },
+            df.select { colGroup("name").col(firstNameAccessor) },
+            df.select { "name".col(firstNameAccessor) },
+            df.select { NonDataSchemaPerson::name.col(firstNameAccessor) },
+            df.select { Person::name.col(firstNameAccessor) },
+            df.select { pathOf("name").col(firstNameAccessor) },
+            // name
+            df.select { name.col("firstName") },
+            df.select { name.col<String>("firstName") },
+            df.select { colGroup("name").col("firstName") },
+            df.select { colGroup("name").col<String>("firstName") },
+            df.select { "name".col("firstName") },
+            df.select { "name".col<String>("firstName") },
+            df.select { NonDataSchemaPerson::name.col("firstName") },
+            df.select { NonDataSchemaPerson::name.col<String>("firstName") },
+            df.select { Person::name.col("firstName") },
+            df.select { Person::name.col<String>("firstName") },
+            df.select { pathOf("name").col("firstName") },
+            df.select { pathOf("name").col<String>("firstName") },
+            // path
+            df.select { name.col(pathOf("firstName")) },
+            df.select { name.col<String>(pathOf("firstName")) },
+            df.select { colGroup("name").col(pathOf("firstName")) },
+            df.select { colGroup("name").col<String>(pathOf("firstName")) },
+            df.select { "name".col(pathOf("firstName")) },
+            df.select { "name".col<String>(pathOf("firstName")) },
+            df.select { NonDataSchemaPerson::name.col(pathOf("firstName")) },
+            df.select { NonDataSchemaPerson::name.col<String>(pathOf("firstName")) },
+            df.select { Person::name.col(pathOf("firstName")) },
+            df.select { Person::name.col<String>(pathOf("firstName")) },
+            df.select { pathOf("name").col(pathOf("firstName")) },
+            df.select { pathOf("name").col<String>(pathOf("firstName")) },
+            df.select { col("name"["firstName"]) },
+            df.select { col<String>("name"["firstName"]) },
+            df.select { asSingleColumn().col("name"["firstName"]) },
+            df.select { asSingleColumn().col<String>("name"["firstName"]) },
+            // property
+            df.select { name.col(Name::firstName) },
+            df.select { colGroup("name").col(Name::firstName) },
+            df.select { "name".col(Name::firstName) },
+            df.select { NonDataSchemaPerson::name.col(Name::firstName) },
+            df.select { Person::name.col(Name::firstName) },
+            df.select { pathOf("name").col(Name::firstName) },
+            // index
+            df.select { name.col(0) },
+            df.select { name.col<String>(0) },
+            df.select { colGroup("name").col(0) },
+            df.select { colGroup("name").col<String>(0) },
+            df.select { "name".col(0) },
+            df.select { "name".col<String>(0) },
+            df.select { NonDataSchemaPerson::name.col(0) },
+            df.select { NonDataSchemaPerson::name.col<String>(0) },
+            df.select { Person::name.col(0) },
+            df.select { Person::name.col<String>(0) },
+            df.select { pathOf("name").col(0) },
+            df.select { pathOf("name").col<String>(0) },
+        ).shouldAllBeEqual()
+    }
+}
diff --git a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/colGroup.kt b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/colGroup.kt
new file mode 100644
index 000000000..293ed61de
--- /dev/null
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/colGroup.kt
@@ -0,0 +1,111 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import io.kotest.assertions.throwables.shouldThrow
+import org.jetbrains.kotlinx.dataframe.samples.api.firstName
+import org.jetbrains.kotlinx.dataframe.samples.api.name
+import org.junit.Test
+
+class ColGroupTests : ColumnsSelectionDslTests() {
+
+    @Test
+    fun `colGroup exceptions`() {
+        shouldThrow<IllegalArgumentException> {
+            dfGroup.select { colGroup("age") }
+        }
+        shouldThrow<IllegalStateException> {
+            dfGroup.select { colGroup("nonExisting") }
+        }
+        shouldThrow<IllegalStateException> {
+            dfGroup.select { name.colGroup("nonExisting") }
+        }
+        shouldThrow<IllegalStateException> {
+            dfGroup.select { "age".colGroup("test") }
+        }
+        shouldThrow<IndexOutOfBoundsException> {
+            dfGroup.select { colGroup(100) }
+        }
+    }
+
+    @Test
+    fun `colGroup at top-level`() {
+        val nameAccessor = columnGroup<Name2>("name")
+        listOf(
+            dfGroup.select { name },
+            dfGroup.select { colGroup(nameAccessor) },
+            dfGroup.select { colGroup("name") },
+            dfGroup.select { colGroup<Name2>("name") },
+            dfGroup.select { colGroup(pathOf("name")) },
+            dfGroup.select { colGroup<Name2>(pathOf("name")) },
+            dfGroup.select { colGroup(Person2::name) },
+            dfGroup.select { colGroups().colGroup(0) },
+            dfGroup.select { all().colGroup(0) },
+            dfGroup.select { colGroup(0) },
+            dfGroup.select { colGroup<Name2>(0) },
+        ).shouldAllBeEqual()
+    }
+
+    @Test
+    fun `frameCol at lower level`() {
+        val firstNamesAccessor = columnGroup<FirstNames>("firstName")
+        listOf(
+            dfGroup.select { name.firstName },
+            // reference
+            dfGroup.select { name.colGroup(firstNamesAccessor) },
+            dfGroup.select { colGroup("name").colGroup(firstNamesAccessor) },
+            dfGroup.select { "name".colGroup(firstNamesAccessor) },
+            dfGroup.select { NonDataSchemaPerson::name.colGroup(firstNamesAccessor) },
+            dfGroup.select { Person2::name.colGroup(firstNamesAccessor) },
+            dfGroup.select { pathOf("name").colGroup(firstNamesAccessor) },
+            // name
+            dfGroup.select { name.colGroup("firstName") },
+            dfGroup.select { name.colGroup<FirstNames>("firstName") },
+            dfGroup.select { colGroup("name").colGroup("firstName") },
+            dfGroup.select { colGroup("name").colGroup<FirstNames>("firstName") },
+            dfGroup.select { "name".colGroup("firstName") },
+            dfGroup.select { "name".colGroup<FirstNames>("firstName") },
+            dfGroup.select { NonDataSchemaPerson::name.colGroup("firstName") },
+            dfGroup.select { NonDataSchemaPerson::name.colGroup<FirstNames>("firstName") },
+            dfGroup.select { Person2::name.colGroup("firstName") },
+            dfGroup.select { Person2::name.colGroup<FirstNames>("firstName") },
+            dfGroup.select { pathOf("name").colGroup("firstName") },
+            dfGroup.select { pathOf("name").colGroup<FirstNames>("firstName") },
+            // path
+            dfGroup.select { name.colGroup(pathOf("firstName")) },
+            dfGroup.select { name.colGroup<FirstNames>(pathOf("firstName")) },
+            dfGroup.select { colGroup("name").colGroup(pathOf("firstName")) },
+            dfGroup.select { colGroup("name").colGroup<FirstNames>(pathOf("firstName")) },
+            dfGroup.select { "name".colGroup(pathOf("firstName")) },
+            dfGroup.select { "name".colGroup<FirstNames>(pathOf("firstName")) },
+            dfGroup.select { NonDataSchemaPerson::name.colGroup(pathOf("firstName")) },
+            dfGroup.select { NonDataSchemaPerson::name.colGroup<FirstNames>(pathOf("firstName")) },
+            dfGroup.select { Person::name.colGroup(pathOf("firstName")) },
+            dfGroup.select { Person::name.colGroup<FirstNames>(pathOf("firstName")) },
+            dfGroup.select { pathOf("name").colGroup(pathOf("firstName")) },
+            dfGroup.select { pathOf("name").colGroup<FirstNames>(pathOf("firstName")) },
+            dfGroup.select { colGroup("name"["firstName"]) },
+            dfGroup.select { colGroup<FirstNames>("name"["firstName"]) },
+            dfGroup.select { asSingleColumn().colGroup("name"["firstName"]) },
+            dfGroup.select { asSingleColumn().colGroup<FirstNames>("name"["firstName"]) },
+            // property
+            dfGroup.select { name.colGroup(Name2::firstName) },
+            dfGroup.select { colGroup("name").colGroup(Name2::firstName) },
+            dfGroup.select { "name".colGroup(Name2::firstName) },
+            dfGroup.select { NonDataSchemaPerson::name.colGroup(Name2::firstName) },
+            dfGroup.select { Person::name.colGroup(Name2::firstName) },
+            dfGroup.select { pathOf("name").colGroup(Name2::firstName) },
+            // index
+            dfGroup.select { name.colGroup(0) },
+            dfGroup.select { name.colGroup<FirstNames>(0) },
+            dfGroup.select { colGroup("name").colGroup(0) },
+            dfGroup.select { colGroup("name").colGroup<FirstNames>(0) },
+            dfGroup.select { "name".colGroup(0) },
+            dfGroup.select { "name".colGroup<FirstNames>(0) },
+            dfGroup.select { NonDataSchemaPerson::name.colGroup(0) },
+            dfGroup.select { NonDataSchemaPerson::name.colGroup<FirstNames>(0) },
+            dfGroup.select { Person2::name.colGroup(0) },
+            dfGroup.select { Person2::name.colGroup<FirstNames>(0) },
+            dfGroup.select { pathOf("name").colGroup(0) },
+            dfGroup.select { pathOf("name").colGroup<FirstNames>(0) },
+        ).shouldAllBeEqual()
+    }
+}
diff --git a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/colGroups.kt b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/colGroups.kt
new file mode 100644
index 000000000..e57d3e70e
--- /dev/null
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/colGroups.kt
@@ -0,0 +1,54 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import io.kotest.assertions.throwables.shouldThrow
+import org.jetbrains.kotlinx.dataframe.AnyRow
+import org.jetbrains.kotlinx.dataframe.samples.api.firstName
+import org.jetbrains.kotlinx.dataframe.samples.api.name
+import org.junit.Test
+
+class ColGroupsTests : ColumnsSelectionDslTests() {
+
+    @Test
+    fun `colGroups exceptions`() {
+        shouldThrow<IllegalArgumentException> {
+            df.select { "age".colGroups() }
+        }
+    }
+
+    @Test
+    fun `colGroups at top-level`() {
+        listOf(
+            df.select { name },
+            df.select { all().colGroups() },
+            df.select { colGroups() },
+        ).shouldAllBeEqual()
+
+        listOf(
+            df.select { name },
+            df.select { name }.select { all() },
+            df.select { name }.select { colGroups() },
+            df.select { name }.select { colGroups().all() },
+            df.select { name }.select { all().colGroups() },
+        ).shouldAllBeEqual()
+
+        listOf(
+            df.select { name },
+            df.select { colGroups { "e" in it.name() } },
+            df.select { all().colGroups { "e" in it.name() } },
+        ).shouldAllBeEqual()
+    }
+
+    @Test
+    fun `colGroups at lower level`() {
+        listOf(
+            dfGroup.select { name.firstName },
+            dfGroup.select { name.colGroups { "Name" in it.name() } },
+            dfGroup.select { name.colsOf<AnyRow> { "Name" in it.name() } },
+            dfGroup.select { name.colsOf<AnyRow>().colGroups { "Name" in it.name() } },
+            dfGroup.select { "name".colGroups { "Name" in it.name() } },
+            dfGroup.select { Person::name.colGroups { "Name" in it.name() } },
+            dfGroup.select { pathOf("name").colGroups { "Name" in it.name() } },
+            dfGroup.select { it["name"].asColumnGroup().colGroups { "Name" in it.name() } },
+        ).shouldAllBeEqual()
+    }
+}
diff --git a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/cols.kt b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/cols.kt
new file mode 100644
index 000000000..102a836b0
--- /dev/null
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/cols.kt
@@ -0,0 +1,296 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import io.kotest.assertions.throwables.shouldThrow
+import org.jetbrains.kotlinx.dataframe.samples.api.age
+import org.jetbrains.kotlinx.dataframe.samples.api.city
+import org.jetbrains.kotlinx.dataframe.samples.api.firstName
+import org.jetbrains.kotlinx.dataframe.samples.api.isHappy
+import org.jetbrains.kotlinx.dataframe.samples.api.lastName
+import org.jetbrains.kotlinx.dataframe.samples.api.name
+import org.jetbrains.kotlinx.dataframe.samples.api.weight
+import org.junit.Test
+
+class ColsTests : ColumnsSelectionDslTests() {
+
+    @Test
+    fun `cols exceptions`() {
+        shouldThrow<IllegalArgumentException> {
+            df.select { "age".cols() }
+        }
+        shouldThrow<IllegalArgumentException> {
+            df.select { cols("non-existent") }
+        }
+        shouldThrow<IllegalArgumentException> {
+            df.select { name.cols("non-existent") }
+        }
+
+        // calls are always relative to the receiver
+        shouldThrow<IllegalArgumentException> {
+            df.select { name.cols(name.firstName) }
+        }
+
+        // "breaking spec" and using a column accessor where it doesn't belong does not work.
+        shouldThrow<IllegalArgumentException> {
+            df.select select1@{
+                name.select {
+                    cols(this@select1.name.firstName)
+                }
+            }
+        }
+    }
+
+    @Test
+    fun `cols and get with predicate`() {
+        listOf(
+            df.select { cols(name, age, city, weight, isHappy) },
+            df.select { all().cols() },
+            df.select { cols() },
+            df.select { all() },
+        ).shouldAllBeEqual()
+
+        listOf(
+            df.select { name },
+            df.select { name }.select { all() },
+            df.select { name }.select { cols() },
+            df.select { name }.select { cols().all() },
+            df.select { name }.select { all().cols() },
+        ).shouldAllBeEqual()
+
+        listOf(
+            df.select { cols(name, age, weight) },
+            df.select { cols { "e" in it.name() } },
+            df.select { this[{ "e" in it.name() }] },
+            df.select { all().cols { "e" in it.name() } },
+            df.select { all()[{ "e" in it.name() }] },
+        ).shouldAllBeEqual()
+
+        listOf(
+            df.select { name.firstName and name.lastName },
+            df.select { name.cols { "Name" in it.name() } },
+            df.select { name[{ "Name" in it.name() }] },
+            df.select { name.colsOf<String>().cols { "Name" in it.name() } },
+            df.select { name.colsOf<String>()[{ "Name" in it.name() }] },
+            df.select { "name".cols { "Name" in it.name() } },
+            df.select { "name"[{ "Name" in it.name() }] },
+            df.select { Person::name.cols { "Name" in it.name() } },
+            df.select { Person::name[{ "Name" in it.name() }] },
+            df.select { NonDataSchemaPerson::name.cols { "Name" in it.name() } },
+            df.select { NonDataSchemaPerson::name[{ "Name" in it.name() }] },
+            df.select { pathOf("name").cols { "Name" in it.name() } },
+            df.select { pathOf("name")[{ "Name" in it.name() }] },
+            df.select { it["name"].asColumnGroup().cols { "Name" in it.name() } },
+            df.select { it["name"].asColumnGroup()[{ "Name" in it.name() }] },
+        ).shouldAllBeEqual()
+    }
+
+    @Test
+    fun `cols and get with column references`() {
+        listOf(
+            df.select { name and age },
+            df.select { cols(name, age) },
+            df.select { this[name, age] },
+            df.select { it[name, age] },
+        ).shouldAllBeEqual()
+
+        val firstName by column<String>()
+        val lastName by column<String>()
+
+        listOf(
+            df.select { name.firstName and name.lastName },
+            df.select { name.cols(firstName, lastName) },
+            df.select { name[firstName, lastName] },
+            df.select {
+                name.select {
+                    cols(firstName, lastName)
+                }
+            },
+            df.select {
+                it["name"].asColumnGroup().select {
+                    cols("firstName", "lastName")
+                }
+            },
+            df.select { "name".cols(firstName, lastName) },
+            df.select { "name"[firstName, lastName] },
+            df.select { Person::name.cols(firstName, lastName) },
+            df.select { Person::name[firstName, lastName] },
+            df.select { NonDataSchemaPerson::name.cols(firstName, lastName) },
+            df.select { NonDataSchemaPerson::name[firstName, lastName] },
+            df.select { pathOf("name").cols(firstName, lastName) },
+            df.select { pathOf("name")[firstName, lastName] },
+            df.select { it["name"].asColumnGroup().cols(firstName, lastName) },
+            df.select { it["name"].asColumnGroup()[firstName, lastName] },
+        ).shouldAllBeEqual()
+    }
+
+    @Test
+    fun `cols and get with column names`() {
+        listOf(
+            df.select { name and age },
+            df.select { cols("name", "age") },
+            df.select { cols<String>("name", "age") },
+            df.select { this["name", "age"] },
+            df.select { it["name", "age"] },
+        ).shouldAllBeEqual()
+
+        listOf(
+            df.select { name.firstName and name.lastName },
+            df.select { name.cols("firstName", "lastName") },
+            df.select { name.cols<String>("firstName", "lastName") },
+            df.select { name["firstName", "lastName"] },
+            df.select { "name".cols("firstName", "lastName") },
+            df.select { "name".cols<String>("firstName", "lastName") },
+            df.select { "name"["firstName", "lastName"] },
+            df.select { "name"["firstName"] and "name"["lastName"] },
+            df.select { Person::name.cols("firstName", "lastName") },
+            df.select { Person::name.cols<String>("firstName", "lastName") },
+            df.select { Person::name["firstName", "lastName"] },
+            df.select { NonDataSchemaPerson::name.cols("firstName", "lastName") },
+            df.select { NonDataSchemaPerson::name.cols<String>("firstName", "lastName") },
+            df.select { NonDataSchemaPerson::name["firstName", "lastName"] },
+            df.select { pathOf("name").cols("firstName", "lastName") },
+            df.select { pathOf("name").cols<String>("firstName", "lastName") },
+            df.select { pathOf("name")["firstName", "lastName"] },
+            df.select { it["name"].asColumnGroup().cols("firstName", "lastName") },
+            df.select { it["name"].asColumnGroup().cols<String>("firstName", "lastName") },
+            df.select { it["name"].asColumnGroup()["firstName", "lastName"] },
+        ).shouldAllBeEqual()
+    }
+
+    @Test
+    fun `cols and get with column paths`() {
+        listOf(
+            df.select { name.firstName },
+            df.select { cols(pathOf("name", "firstName")) },
+            df.select { cols<String>(pathOf("name", "firstName")) },
+            df.select { this[pathOf("name", "firstName")] },
+            df.select { it[pathOf("name", "firstName")] },
+            df.select { pathOf("name", "firstName") },
+        ).shouldAllBeEqual()
+
+        listOf(
+            df.select { name and age },
+            df.select { cols(pathOf("name"), pathOf("age")) },
+            df.select { cols<Any>(pathOf("name"), pathOf("age")) },
+            df.select { this[pathOf("name"), pathOf("age")] },
+            df.select { it[pathOf("name"), pathOf("age")] },
+        ).shouldAllBeEqual()
+
+        listOf(
+            df.select { name.firstName and name.lastName },
+            df.select { name.cols(pathOf("firstName"), pathOf("lastName")) },
+            df.select { name.cols<String>(pathOf("firstName"), pathOf("lastName")) },
+            df.select { name[pathOf("firstName"), pathOf("lastName")] },
+            df.select { "name".cols(pathOf("firstName"), pathOf("lastName")) },
+            df.select { "name".cols<String>(pathOf("firstName"), pathOf("lastName")) },
+            df.select { "name"[pathOf("firstName"), pathOf("lastName")] },
+            df.select { Person::name.cols(pathOf("firstName"), pathOf("lastName")) },
+            df.select { Person::name.cols<String>(pathOf("firstName"), pathOf("lastName")) },
+            df.select { Person::name[pathOf("firstName"), pathOf("lastName")] },
+            df.select { NonDataSchemaPerson::name.cols(pathOf("firstName"), pathOf("lastName")) },
+            df.select { NonDataSchemaPerson::name.cols<String>(pathOf("firstName"), pathOf("lastName")) },
+            df.select { NonDataSchemaPerson::name[pathOf("firstName"), pathOf("lastName")] },
+            df.select { pathOf("name").cols(pathOf("firstName"), pathOf("lastName")) },
+            df.select { pathOf("name").cols<String>(pathOf("firstName"), pathOf("lastName")) },
+            df.select { pathOf("name")[pathOf("firstName"), pathOf("lastName")] },
+            df.select { it["name"].asColumnGroup().cols(pathOf("firstName"), pathOf("lastName")) },
+            df.select { it["name"].asColumnGroup().cols<String>(pathOf("firstName"), pathOf("lastName")) },
+            df.select { it["name"].asColumnGroup()[pathOf("firstName"), pathOf("lastName")] },
+        ).shouldAllBeEqual()
+    }
+
+    @Test
+    fun `cols and get with KProperties`() {
+        listOf(
+            df.select { name and age },
+            df.select { cols(Person::name, Person::age) },
+            df.select { this[Person::name, Person::age] },
+            df.select { it[Person::name, Person::age] },
+        ).shouldAllBeEqual()
+
+        listOf(
+            df.select { name.firstName and name.lastName },
+            df.select { name.cols(Name::firstName, Name::lastName) },
+            df.select { name[Name::firstName, Name::lastName] },
+            df.select { "name".cols(Name::firstName, Name::lastName) },
+            df.select { "name"[Name::firstName, Name::lastName] },
+            df.select { columnGroup(Person::name).cols(Name::firstName, Name::lastName) },
+            df.select { columnGroup(Person::name)[Name::firstName, Name::lastName] },
+            df.select { columnGroup(NonDataSchemaPerson::name).cols(Name::firstName, Name::lastName) },
+            df.select { columnGroup(NonDataSchemaPerson::name)[Name::firstName, Name::lastName] },
+            df.select { pathOf("name").cols(Name::firstName, Name::lastName) },
+            df.select { pathOf("name")[Name::firstName, Name::lastName] },
+            df.select { it["name"].asColumnGroup().cols(Name::firstName, Name::lastName) },
+            df.select { it["name"].asColumnGroup()[Name::firstName, Name::lastName] },
+        ).shouldAllBeEqual()
+    }
+
+    @Test
+    fun `cols and get with indices`() {
+        listOf(
+            df.select { name and age },
+            df.select { cols(0, 1) },
+            df.select { cols<Any>(0, 1) },
+            df.select { all().cols(0, 1) },
+            df.select { all()[0, 1] },
+        ).shouldAllBeEqual()
+
+        listOf(
+            df.select { name.firstName and name.lastName },
+            df.select { name.cols(0, 1) },
+            df.select { name.cols<String>(0, 1) },
+            df.select { name.colsOf<String>().cols(0, 1) },
+            df.select { name.colsOf<String>().cols(0, 1) },
+            df.select { name.colsOf<String>()[0, 1] },
+            df.select { "name".cols(0, 1) },
+            df.select { "name".cols<String>(0, 1) },
+            df.select { Person::name.cols(0, 1) },
+            df.select { Person::name.cols<String>(0, 1) },
+            df.select { pathOf("name").cols(0, 1) },
+            df.select { pathOf("name").cols<String>(0, 1) },
+            df.select { it["name"].asColumnGroup().cols(0, 1) },
+            df.select { it["name"].asColumnGroup().cols<String>(0, 1) },
+        ).shouldAllBeEqual()
+    }
+
+    @Test
+    fun `cols and get with range`() {
+        listOf(
+            df.select { name and age },
+            df.select { cols(0..1) },
+            df.select { cols<Any>(0..1) },
+            df.select { all().cols(0..1) },
+            df.select { all()[0..1] },
+        ).shouldAllBeEqual()
+
+        listOf(
+            df.select { name.firstName and name.lastName },
+            df.select { name.cols(0..1) },
+            df.select { name.cols<String>(0..1) },
+            df.select { name.colsOf<String>().cols(0..1) },
+            df.select { name.colsOf<String>()[0..1] },
+            df.select { "name".cols(0..1) },
+            df.select { "name".cols<String>(0..1) },
+            df.select { Person::name.cols(0..1) },
+            df.select { Person::name.cols<String>(0..1) },
+            df.select { NonDataSchemaPerson::name.cols(0..1) },
+            df.select { NonDataSchemaPerson::name.cols<String>(0..1) },
+            df.select { pathOf("name").cols(0..1) },
+            df.select { pathOf("name").cols<String>(0..1) },
+            df.select { it["name"].asColumnGroup().cols(0..1) },
+            df.select { it["name"].asColumnGroup().cols<String>(0..1) },
+        ).shouldAllBeEqual()
+    }
+
+    @Test
+    fun `triple nested accessor edge case`() {
+        listOf(
+            dfGroup.select { name.firstName.firstName and name.lastName },
+            // column paths are relative to the receiver
+            dfGroup.select { name.cols("firstName"["firstName"], pathOf("lastName")) },
+            // column accessors can only be relative
+            dfGroup.select { name.cols(colGroup("firstName").col("firstName"), col("lastName")) },
+            // so not absolute
+//            dfGroup.select { name.cols(name.firstName.firstName, name.lastName) },
+        ).shouldAllBeEqual()
+    }
+}
diff --git a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/colsAtAnyDepth.kt b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/colsAtAnyDepth.kt
new file mode 100644
index 000000000..fa5adc596
--- /dev/null
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/colsAtAnyDepth.kt
@@ -0,0 +1,169 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import io.kotest.matchers.shouldBe
+import org.jetbrains.kotlinx.dataframe.columns.ColumnKind.Frame
+import org.jetbrains.kotlinx.dataframe.columns.ColumnKind.Group
+import org.jetbrains.kotlinx.dataframe.columns.ColumnKind.Value
+import org.jetbrains.kotlinx.dataframe.columns.ColumnSet
+import org.jetbrains.kotlinx.dataframe.columns.ColumnWithPath
+import org.jetbrains.kotlinx.dataframe.columns.asColumnSet
+import org.jetbrains.kotlinx.dataframe.impl.columns.TransformableColumnSet
+import org.jetbrains.kotlinx.dataframe.impl.columns.atAnyDepthImpl
+import org.jetbrains.kotlinx.dataframe.impl.columns.transform
+import org.jetbrains.kotlinx.dataframe.impl.columns.tree.flattenRecursively
+import org.jetbrains.kotlinx.dataframe.kind
+import org.jetbrains.kotlinx.dataframe.samples.api.TestBase
+import org.jetbrains.kotlinx.dataframe.samples.api.city
+import org.jetbrains.kotlinx.dataframe.samples.api.firstName
+import org.jetbrains.kotlinx.dataframe.samples.api.lastName
+import org.jetbrains.kotlinx.dataframe.samples.api.name
+import org.junit.Test
+import kotlin.reflect.typeOf
+
+class AtAnyDepth : TestBase() {
+
+    // old function copied over to avoid breaking changes
+    private fun ColumnSet<*>.dfsInternal(predicate: (ColumnWithPath<*>) -> Boolean): TransformableColumnSet<Any?> =
+        transform {
+            it.filter { it.isColumnGroup() }
+                .flatMap { it.cols().flattenRecursively().filter(predicate) }
+        }
+
+    private val atAnyDepthGoal =
+        dfGroup.getColumnsWithPaths {
+            asSingleColumn().ensureIsColumnGroup().asColumnSet().dfsInternal { true }
+        }.sortedBy { it.name }
+
+    private val atAnyDepthNoGroups =
+        dfGroup.getColumnsWithPaths {
+            asSingleColumn().ensureIsColumnGroup().asColumnSet().dfsInternal { !it.isColumnGroup() }
+        }.sortedBy { it.name }
+
+    private val atAnyDepthString =
+        dfGroup.getColumnsWithPaths {
+            asSingleColumn()
+                .ensureIsColumnGroup()
+                .asColumnSet()
+                .dfsInternal { it.isSubtypeOf(typeOf<String?>()) }
+        }.sortedBy { it.name }
+
+    @Test
+    fun `first, last, and single`() {
+        listOf(
+            dfGroup.select { name.firstName.firstName },
+            dfGroup.select { first { col -> col.any { it == "Alice" } }.atAnyDepthImpl() },
+            dfGroup.select { colsAtAnyDepth().first { col -> col.any { it == "Alice" } } },
+            dfGroup.select { colsAtAnyDepth { col -> col.any { it == "Alice" } }.first() },
+            dfGroup.select { colsAtAnyDepth().last { col -> col.any { it == "Alice" } } },
+            dfGroup.select { colsAtAnyDepth { col -> col.any { it == "Alice" } }.last() },
+            dfGroup.select { colsAtAnyDepth().single { col -> col.any { it == "Alice" } } },
+            dfGroup.select { colsAtAnyDepth { col -> col.any { it == "Alice" } }.single() },
+        ).shouldAllBeEqual()
+
+        listOf(
+            dfGroup.select { city },
+            dfGroup.select { colsAtAnyDepth().first { col -> col.any { it == "London" } } },
+            dfGroup.select { colsAtAnyDepth { col -> col.any { it == "London" } }.first() },
+            dfGroup.select { colsAtAnyDepth().last { col -> col.any { it == "London" } } },
+            dfGroup.select { colsAtAnyDepth { col -> col.any { it == "London" } }.last() },
+            dfGroup.select { colsAtAnyDepth().single { col -> col.any { it == "London" } } },
+            dfGroup.select { colsAtAnyDepth { col -> col.any { it == "London" } }.single() },
+        ).shouldAllBeEqual()
+    }
+
+    @Test
+    fun groups() {
+        listOf(
+            df.select { name },
+            df.select { colsAtAnyDepth().colGroups() },
+            df.select { colsAtAnyDepth { it.kind == Group } },
+            df.select { colGroups() },
+            df.select { all().colGroups() },
+            df.select { all().colsAtAnyDepth().colGroups() },
+        ).shouldAllBeEqual()
+
+        dfGroup.select { colGroups() } shouldBe dfGroup.select { name }
+        dfGroup.select { colsAtAnyDepth().colGroups() } shouldBe dfGroup.select { name and name.firstName }
+    }
+
+    @Test
+    fun `all atAnyDepth`() {
+        dfGroup.getColumnsWithPaths { colsAtAnyDepth().all() }.sortedBy { it.name } shouldBe atAnyDepthGoal
+        dfGroup
+            .getColumnsWithPaths { all().colsAtAnyDepth().cols { !it.isColumnGroup() } }
+            .sortedBy { it.name } shouldBe atAnyDepthNoGroups
+    }
+
+    @Test
+    fun `cols atAnyDepth`() {
+        dfGroup.getColumnsWithPaths { colsAtAnyDepth().cols() }.sortedBy { it.name } shouldBe atAnyDepthGoal
+    }
+
+    @Test
+    fun `colsOf atAnyDepth`() {
+        dfGroup.getColumnsWithPaths { colsAtAnyDepth().colsOf<String?>() }.sortedBy { it.name } shouldBe
+            atAnyDepthString
+    }
+
+    @Test
+    fun `all allAtAnyDepth`() {
+        dfGroup.getColumnsWithPaths { all().colsAtAnyDepth().all() }.sortedBy { it.name } shouldBe atAnyDepthGoal
+        dfGroup
+            .getColumnsWithPaths { all().colsAtAnyDepth { !it.isColumnGroup() } }
+            .sortedBy { it.name } shouldBe atAnyDepthNoGroups
+    }
+
+    @Test
+    fun `cols allAtAnyDepth`() {
+        dfGroup.getColumnsWithPaths { cols().colsAtAnyDepth().all() }.sortedBy { it.name } shouldBe atAnyDepthGoal
+        dfGroup
+            .getColumnsWithPaths { cols().colsAtAnyDepth { !it.isColumnGroup() } }
+            .sortedBy { it.name } shouldBe atAnyDepthNoGroups
+    }
+
+    @Test
+    fun `valueCols atAnyDepth`() {
+        dfGroup.getColumnsWithPaths { colsAtAnyDepth().valueCols() }.sortedBy { it.name } shouldBe
+            atAnyDepthNoGroups
+    }
+
+    @Test
+    fun `colGroups atAnyDepth`() {
+        dfGroup.getColumnsWithPaths { colsAtAnyDepth().colGroups() } shouldBe
+            dfGroup.getColumnsWithPaths { name and name.firstName }
+    }
+
+    @Test
+    fun `frameCols atAnyDepth`() {
+        val frameCol by frameColumn<Person>()
+
+        val dfWithFrames = df
+            .add { expr { df } into frameCol }
+            .convert { name }.to {
+                val firstName by it.asColumnGroup().firstName
+                val lastName by it.asColumnGroup().lastName
+
+                @Suppress("NAME_SHADOWING")
+                val frameCol by it.map { df }.asFrameColumn()
+
+                dataFrameOf(firstName, lastName, frameCol).asColumnGroup("name")
+            }
+
+        dfWithFrames.getColumnsWithPaths { colsAtAnyDepth().frameCols() } shouldBe
+            dfWithFrames.getColumnsWithPaths { name[frameCol] and frameCol }
+    }
+
+    //    @Test
+    fun `cols of kind atAnyDepth`() {
+        listOf(
+            dfGroup.getColumnsWithPaths {
+                colsAtAnyDepth().colsOfKind(Frame, Value) { "e" in it.name }
+            },
+            dfGroup.getColumnsWithPaths {
+                asSingleColumn().ensureIsColumnGroup().asColumnSet().dfsInternal { "e" in it.name }
+            },
+        ).map {
+            it.sortedBy { it.name }.map { it.name to it.path }
+        }.shouldAllBeEqual()
+    }
+}
diff --git a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/colsInGroups.kt b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/colsInGroups.kt
new file mode 100644
index 000000000..4cbb6bdb4
--- /dev/null
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/colsInGroups.kt
@@ -0,0 +1,58 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import io.kotest.assertions.throwables.shouldThrow
+import org.jetbrains.kotlinx.dataframe.samples.api.firstName
+import org.jetbrains.kotlinx.dataframe.samples.api.lastName
+import org.jetbrains.kotlinx.dataframe.samples.api.name
+import org.jetbrains.kotlinx.dataframe.samples.api.secondName
+import org.jetbrains.kotlinx.dataframe.samples.api.thirdName
+import org.junit.Test
+
+class ColsInGroupsTests : ColumnsSelectionDslTests() {
+
+    @Test
+    fun exceptions() {
+        shouldThrow<IllegalArgumentException> {
+            df.select { "age".colsInGroups() }
+        }
+        shouldThrow<IllegalArgumentException> {
+            df.select { columnGroup(Person::age).colsInGroups() }
+        }
+        shouldThrow<IllegalArgumentException> {
+            df.select { Person::age.colsInGroups() }
+        }
+    }
+
+    @Test
+    fun `cols in groups`() {
+        listOf(
+            df.select { name { firstName and lastName } },
+            df.select { colsInGroups() },
+            df.select { all().colsInGroups() },
+            df.select { colGroups().colsInGroups() },
+        ).shouldAllBeEqual()
+
+        listOf(
+            df.select { name.firstName },
+            df.select { colsInGroups { "first" in it.name } },
+            df.select { all().colsInGroups { "first" in it.name } },
+            df.select { colGroups().colsInGroups { "first" in it.name } },
+        ).shouldAllBeEqual()
+
+        listOf(
+            dfGroup.select { name.firstName { cols(firstName, secondName, thirdName) } },
+            dfGroup.select { name.colsInGroups() },
+            dfGroup.select { "name".colsInGroups() },
+            dfGroup.select { Person2::name.colsInGroups() },
+            dfGroup.select { pathOf("name").colsInGroups() },
+        ).shouldAllBeEqual()
+
+        listOf(
+            dfGroup.select { name.firstName.firstName },
+            dfGroup.select { name.colsInGroups { "first" in it.name } },
+            dfGroup.select { "name".colsInGroups { "first" in it.name } },
+            dfGroup.select { Person2::name.colsInGroups { "first" in it.name } },
+            dfGroup.select { pathOf("name").colsInGroups { "first" in it.name } },
+        ).shouldAllBeEqual()
+    }
+}
diff --git a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/colsOf.kt b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/colsOf.kt
new file mode 100644
index 000000000..a3a4d3cb1
--- /dev/null
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/colsOf.kt
@@ -0,0 +1,42 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import org.jetbrains.kotlinx.dataframe.samples.api.age
+import org.jetbrains.kotlinx.dataframe.samples.api.city
+import org.jetbrains.kotlinx.dataframe.samples.api.firstName
+import org.jetbrains.kotlinx.dataframe.samples.api.lastName
+import org.jetbrains.kotlinx.dataframe.samples.api.name
+import org.junit.Test
+import kotlin.reflect.typeOf
+
+class ColsOfTests : ColumnsSelectionDslTests() {
+
+    @Test
+    fun `top level`() {
+        listOf(
+            df.select { city },
+            df.select { colsOf<String?>() },
+            df.select { all().colsOf<String?>() },
+        ).shouldAllBeEqual()
+
+        listOf(
+            df.select { age },
+            df.select { colsOf<Int?> { "a" in it.name } },
+            df.select { all().colsOf<Int?> { "a" in it.name } },
+        ).shouldAllBeEqual()
+    }
+
+    @Test
+    fun `lower level`() {
+        listOf(
+            df.select { name { firstName and lastName } },
+            df.select { name.colsOf<String>() },
+            df.select { name.colsOf<String> { "Name" in it.name } },
+            df.select { "name".colsOf<String>(typeOf<String>()) },
+            df.select { "name".colsOf<String>(typeOf<String>()) { "Name" in it.name } },
+            df.select { Person::name.colsOf<String>(typeOf<String>()) },
+            df.select { Person::name.colsOf<String>(typeOf<String>()) { "Name" in it.name } },
+            df.select { pathOf("name").colsOf<String>(typeOf<String>()) },
+            df.select { pathOf("name").colsOf<String>(typeOf<String>()) { "Name" in it.name } },
+        ).shouldAllBeEqual()
+    }
+}
diff --git a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/colsOfKind.kt b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/colsOfKind.kt
new file mode 100644
index 000000000..492d5f9a6
--- /dev/null
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/colsOfKind.kt
@@ -0,0 +1,65 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import io.kotest.assertions.throwables.shouldThrow
+import org.jetbrains.kotlinx.dataframe.columns.ColumnKind.Frame
+import org.jetbrains.kotlinx.dataframe.columns.ColumnKind.Group
+import org.jetbrains.kotlinx.dataframe.columns.ColumnKind.Value
+import org.jetbrains.kotlinx.dataframe.samples.api.age
+import org.jetbrains.kotlinx.dataframe.samples.api.city
+import org.jetbrains.kotlinx.dataframe.samples.api.firstName
+import org.jetbrains.kotlinx.dataframe.samples.api.isHappy
+import org.jetbrains.kotlinx.dataframe.samples.api.lastName
+import org.jetbrains.kotlinx.dataframe.samples.api.name
+import org.jetbrains.kotlinx.dataframe.samples.api.weight
+import org.junit.Test
+
+class ColsOfKindTests : ColumnsSelectionDslTests() {
+
+    @Test
+    fun `colsOfKind exceptions`() {
+        shouldThrow<IllegalArgumentException> {
+            df.select { "age".colsOfKind(Value) }
+        }
+    }
+
+    @Test
+    fun `colsOfKind at top-level`() {
+        listOf(
+            df.select { all() },
+            df.select { colsOfKind(Value, Group) },
+        ).shouldAllBeEqual()
+
+        listOf(
+            df.select { cols(age, city, weight, isHappy) },
+            df.select { all().colsOfKind(Value) },
+            df.select { colsOfKind(Value) },
+        ).shouldAllBeEqual()
+
+        listOf(
+            df.select { age },
+            df.select { age }.select { colsOfKind(Value) },
+            df.select { age }.select { colsOfKind(Value, Value) },
+            df.select { age }.select { colsOfKind(Value).all() },
+            df.select { age }.select { all().colsOfKind(Value) },
+        ).shouldAllBeEqual()
+
+        listOf(
+            df.select { cols(age, weight) },
+            df.select { colsOfKind(Value, Frame) { "e" in it.name() } },
+            df.select { all().colsOfKind(Value, Frame) { "e" in it.name() } },
+        ).shouldAllBeEqual()
+    }
+
+    @Test
+    fun `colsOfKind at lower level`() {
+        listOf(
+            df.select { name.firstName and name.lastName },
+            df.select { name.colsOfKind(Value) { "Name" in it.name() } },
+            df.select { name.colsOf<String>().colsOfKind(Value) { "Name" in it.name() } },
+            df.select { "name".colsOfKind(Value) { "Name" in it.name() } },
+            df.select { Person::name.colsOfKind(Value) { "Name" in it.name() } },
+            df.select { pathOf("name").colsOfKind(Value) { "Name" in it.name() } },
+            df.select { it["name"].asColumnGroup().colsOfKind(Value) { "Name" in it.name() } },
+        ).shouldAllBeEqual()
+    }
+}
diff --git a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/columnNameFilters.kt b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/columnNameFilters.kt
new file mode 100644
index 000000000..1d8fd94ed
--- /dev/null
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/columnNameFilters.kt
@@ -0,0 +1,78 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import org.jetbrains.kotlinx.dataframe.samples.api.age
+import org.jetbrains.kotlinx.dataframe.samples.api.firstName
+import org.jetbrains.kotlinx.dataframe.samples.api.lastName
+import org.jetbrains.kotlinx.dataframe.samples.api.name
+import org.junit.Test
+
+class ColumnNameFiltersTests : ColumnsSelectionDslTests() {
+
+    @Test
+    fun nameContains() {
+        listOf(
+            df.select { age },
+            df.select { nameContains("age") },
+            df.select { nameContains("AGE", ignoreCase = true) },
+            df.select { nameContains(Regex("age")) },
+            df.select { all().nameContains("age") },
+            df.select { all().nameContains("AGE", ignoreCase = true) },
+            df.select { all().nameContains(Regex("age")) },
+        ).shouldAllBeEqual()
+
+        listOf(
+            df.select { name.firstName },
+            df.select { name.colsNameContains("first") },
+            df.select { "name".colsNameContains("first") },
+            df.select { Person::name.colsNameContains("first") },
+            df.select { pathOf("name").colsNameContains("first") },
+            df.select { name.colsNameContains("FIRST", ignoreCase = true) },
+            df.select { "name".colsNameContains("FIRST", ignoreCase = true) },
+            df.select { Person::name.colsNameContains("FIRST", ignoreCase = true) },
+            df.select { pathOf("name").colsNameContains("FIRST", ignoreCase = true) },
+            df.select { name.colsNameContains(Regex("first")) },
+            df.select { "name".colsNameContains(Regex("first")) },
+            df.select { Person::name.colsNameContains(Regex("first")) },
+            df.select { pathOf("name").colsNameContains(Regex("first")) },
+        ).shouldAllBeEqual()
+    }
+
+    @Test
+    fun `nameStartsWith and nameEndsWith`() {
+        listOf(
+            df.select { age },
+            df.select { nameStartsWith("age") },
+            df.select { nameStartsWith("AGE", ignoreCase = true) },
+            df.select { nameEndsWith("age") },
+            df.select { nameEndsWith("AGE", ignoreCase = true) },
+            df.select { all().nameStartsWith("age") },
+            df.select { all().nameStartsWith("AGE", ignoreCase = true) },
+            df.select { all().nameEndsWith("age") },
+            df.select { all().nameEndsWith("AGE", ignoreCase = true) },
+        ).shouldAllBeEqual()
+
+        listOf(
+            df.select { name.firstName },
+            df.select { name.colsNameStartsWith("first") },
+            df.select { "name".colsNameStartsWith("first") },
+            df.select { Person::name.colsNameStartsWith("first") },
+            df.select { pathOf("name").colsNameStartsWith("first") },
+            df.select { name.colsNameStartsWith("FIRST", ignoreCase = true) },
+            df.select { "name".colsNameStartsWith("FIRST", ignoreCase = true) },
+            df.select { Person::name.colsNameStartsWith("FIRST", ignoreCase = true) },
+            df.select { pathOf("name").colsNameStartsWith("FIRST", ignoreCase = true) },
+        ).shouldAllBeEqual()
+
+        listOf(
+            df.select { name.firstName and name.lastName },
+            df.select { name.colsNameEndsWith("Name") },
+            df.select { "name".colsNameEndsWith("Name") },
+            df.select { Person::name.colsNameEndsWith("Name") },
+            df.select { pathOf("name").colsNameEndsWith("Name") },
+            df.select { name.colsNameEndsWith("NAME", ignoreCase = true) },
+            df.select { "name".colsNameEndsWith("NAME", ignoreCase = true) },
+            df.select { Person::name.colsNameEndsWith("NAME", ignoreCase = true) },
+            df.select { pathOf("name").colsNameEndsWith("NAME", ignoreCase = true) },
+        ).shouldAllBeEqual()
+    }
+}
diff --git a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/columnRange.kt b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/columnRange.kt
new file mode 100644
index 000000000..eae9bd8a7
--- /dev/null
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/columnRange.kt
@@ -0,0 +1,61 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import io.kotest.assertions.throwables.shouldThrow
+import io.kotest.matchers.shouldBe
+import org.jetbrains.kotlinx.dataframe.samples.api.age
+import org.jetbrains.kotlinx.dataframe.samples.api.city
+import org.jetbrains.kotlinx.dataframe.samples.api.firstName
+import org.jetbrains.kotlinx.dataframe.samples.api.lastName
+import org.jetbrains.kotlinx.dataframe.samples.api.name
+import org.jetbrains.kotlinx.dataframe.samples.api.weight
+import org.junit.Test
+
+class ColumnRangeTest : ColumnsSelectionDslTests() {
+
+    @Test
+    fun `top level columns`() {
+        listOf(
+            df.select { age and city and weight },
+            df.select { "age".."weight" },
+            df.select { "age"..Person::weight },
+            df.select { "age"..weight },
+            df.select { "age"..pathOf("weight") },
+            df.select { Person::age.."weight" },
+            df.select { Person::age..Person::weight },
+            df.select { Person::age..weight },
+            df.select { Person::age..pathOf("weight") },
+            df.select { age.."weight" },
+            df.select { age..Person::weight },
+            df.select { age..weight },
+            df.select { age..pathOf("weight") },
+            df.select { pathOf("age").."weight" },
+            df.select { pathOf("age")..Person::weight },
+            df.select { pathOf("age")..weight },
+            df.select { pathOf("age")..pathOf("weight") },
+        ).shouldAllBeEqual()
+
+        // range of single column
+        df.select { age..age } shouldBe df.select { age }
+
+        // wrong order
+        shouldThrow<IllegalArgumentException> {
+            df.select { weight..age }
+        }
+    }
+
+    @Test
+    fun `inside column group`() {
+        listOf(
+            df.select { name.firstName and name.lastName },
+            df.select { name.firstName..name.lastName },
+            df.select { name.firstName.."name"["lastName"] },
+            df.select { "name"["firstName"]..name.lastName },
+            df.select { "name"["firstName"].."name"["lastName"] },
+        ).shouldAllBeEqual()
+
+        // other parent
+        shouldThrow<IllegalArgumentException> {
+            df.select { name.firstName..age }
+        }
+    }
+}
diff --git a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/concat.kt b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/concat.kt
new file mode 100644
index 000000000..c290e500f
--- /dev/null
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/concat.kt
@@ -0,0 +1,14 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import io.kotest.matchers.shouldBe
+import org.junit.Test
+
+class ConcatTests {
+
+    @Test
+    fun `different types`() {
+        val a by columnOf(1, 2)
+        val b by columnOf(3.0, null)
+        a.concat(b) shouldBe columnOf(1, 2, 3.0, null).named("a")
+    }
+}
diff --git a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/contains.kt b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/contains.kt
new file mode 100644
index 000000000..542e1b06b
--- /dev/null
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/contains.kt
@@ -0,0 +1,65 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import io.kotest.matchers.shouldBe
+import org.junit.Test
+
+class ContainsTests {
+
+    @Test
+    fun `column contains`() {
+        val col by columnOf(1, 3, 5)
+        col.contains(3) shouldBe true
+        col.contains(2) shouldBe false
+    }
+
+    @Test
+    fun `column group contains`() {
+        val df = dataFrameOf("a", "b")(1, 2, 3, 4)
+        val col = df.asColumnGroup("col")
+        col.contains(df[0]) shouldBe true
+        col.contains(df.update("b").with { 0 }[0]) shouldBe false
+    }
+
+    @Test
+    fun `contains column`() {
+        val a by column<Int>()
+        val df = dataFrameOf("a")(1, 2)
+        (a in df) shouldBe true
+        df.containsColumn(a) shouldBe true
+        df.containsColumn("a") shouldBe true
+        df.containsColumn(df["a"]) shouldBe true
+        val b by column<Int>()
+        (b in df) shouldBe false
+        df.containsColumn(b) shouldBe false
+    }
+
+    @Test
+    fun `contains nested column`() {
+        val g by columnGroup()
+        val a by g.column<Int>()
+
+        val df = dataFrameOf("a")(1, 2).group("a").into("g")
+        (a in df) shouldBe true
+    }
+
+    @Test
+    fun `row contains key`() {
+        val a by column<Int>()
+        val b by column<Int>()
+
+        data class A(val a: Int, val b: Int)
+
+        val df = dataFrameOf("a")(1, 2)
+        val row = df[0]
+
+        row.containsKey("a") shouldBe true
+        row.containsKey(a) shouldBe true
+        row.containsKey(A::a) shouldBe true
+        (A::a in row) shouldBe true
+        (a in row) shouldBe true
+
+        row.containsKey("b") shouldBe false
+        row.containsKey(b) shouldBe false
+        row.containsKey(A::b) shouldBe false
+    }
+}
diff --git a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/convert.kt b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/convert.kt
new file mode 100644
index 000000000..31879e263
--- /dev/null
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/convert.kt
@@ -0,0 +1,175 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import io.kotest.assertions.throwables.shouldNotThrow
+import io.kotest.assertions.throwables.shouldThrow
+import io.kotest.matchers.shouldBe
+import kotlinx.datetime.Clock
+import kotlinx.datetime.Instant
+import kotlinx.datetime.LocalTime
+import org.jetbrains.kotlinx.dataframe.DataColumn
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.annotations.DataSchema
+import org.jetbrains.kotlinx.dataframe.exceptions.CellConversionException
+import org.jetbrains.kotlinx.dataframe.exceptions.TypeConversionException
+import org.jetbrains.kotlinx.dataframe.exceptions.TypeConverterNotFoundException
+import org.jetbrains.kotlinx.dataframe.hasNulls
+import org.junit.Test
+import kotlin.reflect.typeOf
+import kotlin.time.Duration.Companion.hours
+
+class ConvertTests {
+
+    @Test
+    fun `convert nullable strings to time`() {
+        val time by columnOf("11?22?33", null)
+        val converted = time.toDataFrame().convert { time }.toLocalTime("HH?mm?ss")[time]
+        converted.hasNulls shouldBe true
+        converted[0] shouldBe LocalTime(11, 22, 33)
+    }
+
+    @Test
+    fun `nullability persistence after conversion`() {
+        val col by columnOf("1", null)
+        col.convertToInt().forEach {
+        }
+    }
+
+    @DataSchema
+    data class Schema(val time: Instant)
+
+    @Test
+    fun `Instant to LocalDateTime`() {
+        val df = listOf(Schema(Clock.System.now())).toDataFrame()
+        df.convert { time }.toLocalDateTime()
+    }
+
+    enum class EnumClass { A, B }
+
+    @Test
+    fun `convert string to enum`() {
+        columnOf("A", "B").convertTo<EnumClass>() shouldBe columnOf(EnumClass.A, EnumClass.B)
+    }
+
+    @JvmInline
+    value class IntClass(val v: Int)
+
+    @JvmInline
+    value class StringClass(val s: String?)
+
+    @JvmInline
+    value class PrivateInt(private val v: Int)
+
+    @Test
+    fun `convert string to value class`() {
+        columnOf("1").convertTo<IntClass>() shouldBe columnOf(IntClass(1))
+    }
+
+    @Test
+    fun `convert double to value class`() {
+        columnOf(1.0).convertTo<IntClass>() shouldBe columnOf(IntClass(1))
+    }
+
+    @Test
+    fun `convert from value class `() {
+        columnOf(IntClass(1)).convertTo<Double>() shouldBe columnOf(1.0)
+        columnOf(StringClass("1"), StringClass(null)).convertTo<Double?>() shouldBe columnOf(1.0, null)
+    }
+
+    @Test
+    fun `convert to value class exceptions`() {
+        shouldThrow<TypeConversionException> {
+            columnOf("a").convertTo<IntClass>()
+        }
+
+        shouldThrow<CellConversionException> {
+            columnOf("1", "10", "a").convertTo<IntClass>()
+        }.row shouldBe 2
+
+        shouldThrow<CellConversionException> {
+            columnOf("1", "x", "2.5").convertToDouble()
+        }.row shouldBe 1
+
+        shouldThrow<TypeConverterNotFoundException> {
+            columnOf(EnumClass.A).convertTo<IntClass>()
+        }
+    }
+
+    @Test
+    fun `convert from value class exceptions`() {
+        shouldThrow<TypeConversionException> {
+            columnOf(StringClass("a")).convertTo<Int>()
+        }.from shouldBe typeOf<String>()
+
+        shouldThrow<TypeConverterNotFoundException> {
+            columnOf(IntClass(1)).convertTo<EnumClass>()
+        }
+
+        shouldThrow<TypeConversionException> {
+            columnOf(StringClass(null)).convertTo<Double>()
+        }
+
+        shouldThrow<TypeConversionException> {
+            columnOf(PrivateInt(1)).convertTo<Double>()
+        }
+    }
+
+    @Test
+    fun `convert null strings`() {
+        val col = columnOf("none")
+
+        shouldThrow<TypeConversionException> {
+            col.convertTo<Int>()
+        }
+
+        shouldThrow<TypeConversionException> {
+            col.convertTo<Int?>()
+        }
+
+        DataFrame.parser.addNullString("none")
+
+        shouldThrow<TypeConversionException> {
+            col.convertTo<Int>()
+        }
+
+        col.convertTo<Int?>() shouldBe DataColumn.createValueColumn("", listOf(null), typeOf<Int?>())
+
+        DataFrame.parser.resetToDefault()
+    }
+
+    @Test
+    fun `convert to not nullable`() {
+        val col = columnOf(1.0, null)
+
+        col.convertToInt() shouldBe columnOf(1, null)
+
+        shouldThrow<TypeConversionException> {
+            col.cast<Double>().convertToInt()
+        }
+
+        col.convertTo<Int?>() shouldBe columnOf(1, null)
+    }
+
+    @Test
+    fun `convert to nullable without nulls`() {
+        val col = columnOf(1.0, 2.0)
+
+        col.convertTo<Int?>().hasNulls() shouldBe false
+    }
+
+    @Test
+    fun `convert instant`() {
+        println(Clock.System.now().toEpochMilliseconds())
+        val kotlinxInstants = columnOf(Instant.fromEpochMilliseconds(1657283006955))
+        shouldNotThrow<TypeConverterNotFoundException> {
+            val javaInstant = kotlinxInstants.convertTo<java.time.Instant>()
+            javaInstant.convertTo<Instant>() shouldBe kotlinxInstants
+        }
+    }
+
+    @Test
+    fun `convert duration to string`() {
+        val col = columnOf(1.hours)
+        val res = col.convertTo<String>()
+        res.print()
+    }
+}
diff --git a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/convertTo.kt b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/convertTo.kt
new file mode 100644
index 000000000..176ab0697
--- /dev/null
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/convertTo.kt
@@ -0,0 +1,338 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import io.kotest.assertions.throwables.shouldThrow
+import io.kotest.matchers.shouldBe
+import org.jetbrains.kotlinx.dataframe.AnyFrame
+import org.jetbrains.kotlinx.dataframe.AnyRow
+import org.jetbrains.kotlinx.dataframe.DataColumn
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.alsoDebug
+import org.jetbrains.kotlinx.dataframe.annotations.DataSchema
+import org.jetbrains.kotlinx.dataframe.columns.ColumnKind
+import org.jetbrains.kotlinx.dataframe.exceptions.TypeConverterNotFoundException
+import org.jetbrains.kotlinx.dataframe.kind
+import org.junit.Test
+import kotlin.reflect.typeOf
+
+@Suppress("ktlint:standard:argument-list-wrapping")
+class ConvertToTests {
+
+    @Test
+    fun `convert frame column with empty frames`() {
+        val groups by columnOf(dataFrameOf("a")("1"), DataFrame.empty())
+        val df = dataFrameOf(groups)
+
+        @DataSchema
+        data class GroupSchema(val a: Int)
+
+        @DataSchema
+        data class DataFrameSchema(val groups: DataFrame<GroupSchema>)
+
+        val converted = df.convertTo<DataFrameSchema>()
+
+        converted[groups].forEach {
+            it["a"].type() shouldBe typeOf<Int>()
+        }
+    }
+
+    data class A(val value: Int)
+
+    @DataSchema
+    data class Schema(val a: A)
+
+    @Test
+    fun `convert with parser`() {
+        val df = dataFrameOf("a")("1")
+
+        shouldThrow<TypeConverterNotFoundException> {
+            df.convertTo<Schema>()
+        }
+
+        df.convertTo<Schema> { parser { A(it.toInt()) } }
+            .single()
+            .a.value shouldBe 1
+    }
+
+    @Test
+    fun `convert with converter`() {
+        val df = dataFrameOf("a")(1)
+
+        shouldThrow<TypeConverterNotFoundException> {
+            df.convertTo<Schema>()
+        }
+
+        df.convertTo<Schema> { convert<Int>().with { A(it) } }
+            .single()
+            .a.value shouldBe 1
+    }
+
+    @Test
+    fun `convert nulls to not nulls with converter`() {
+        val df = dataFrameOf("a")("1", null)
+
+        val converted = df.convertTo<Schema> {
+            convert<String?>().with { it?.let { A(it.toInt()) } ?: A(0) }
+        }
+        val expected = dataFrameOf("a")(A(1), A(0))
+
+        converted shouldBe expected
+    }
+
+    @JvmInline
+    value class IntClass(val value: Int)
+
+    @DataSchema
+    interface IntSchema {
+        val a: IntClass?
+    }
+
+    @Test
+    fun `convert value class with converter`() {
+        dataFrameOf("a")("1%")
+            .convertTo<IntSchema> {
+                parser { IntClass(it.dropLast(1).toInt()) }
+            } shouldBe dataFrameOf("a")(IntClass(1))
+    }
+
+    @Test
+    fun `convert nulls with converter`() {
+        dataFrameOf("a")("1%", null)
+            .convertTo<IntSchema> {
+                parser { IntClass(it.dropLast(1).toInt()) }
+            } shouldBe dataFrameOf("a")(IntClass(1), null)
+    }
+
+    @Test
+    fun `convert with nullable converter argument`() {
+        val df = dataFrameOf("a")("1")
+
+        val converted = df.convertTo<IntSchema> {
+            convert<String?>().with {
+                it?.let { IntClass(it.toInt()) }
+            }
+        }
+        val expected = dataFrameOf("a")(IntClass(1))
+
+        converted shouldBe expected
+    }
+
+    @DataSchema
+    data class Location(val name: String, val gps: Gps?)
+
+    @DataSchema
+    data class Gps(val latitude: Double, val longitude: Double)
+
+    // @Test TODO: https://github.com/Kotlin/dataframe/issues/177
+    fun `convert df with nullable DataRow`() {
+        val locations: AnyFrame = dataFrameOf("name", "gps")(
+            "Home", Gps(0.0, 0.0),
+            "Away", null,
+        )
+
+        locations.print(borders = true, title = true, columnTypes = true)
+        locations.schema().print()
+
+        val converted = locations.convertTo<Location>()
+
+        converted shouldBe locations
+    }
+
+    @Test
+    fun `convert df with nullable DataRow to itself`() {
+        val locations: DataFrame<Location> = listOf(
+            Location("Home", Gps(0.0, 0.0)),
+            Location("Away", null),
+        ).toDataFrame()
+
+        val converted = locations.convertTo<Location>()
+
+        converted shouldBe locations
+    }
+
+    @DataSchema
+    data class DataSchemaWithAnyFrame(val dfs: AnyFrame?)
+
+    @Test
+    fun test() {
+        val df1 = dataFrameOf("a")(1, 2, 3)
+        val df2 = dataFrameOf("b")(4, 5)
+        val frameColumn by columnOf(df1, df2, null)
+        val df = dataFrameOf(frameColumn).alsoDebug()
+//        ⌌---------------⌍
+//        |  | untitled:[]|
+//        |--|------------|
+//        | 0|     [3 x 1]|
+//        | 1|     [2 x 1]|
+//        | 2|     [0 x 0]|
+//        ⌎---------------⌏
+//
+//        untitled: *
+    }
+
+    @Test
+    fun `convert df with AnyFrame to itself`() {
+        val locationsList = listOf(
+            Location("Home", Gps(0.0, 0.0)),
+            Location("Away", null),
+            null,
+        )
+        val locations = locationsList
+            .toDataFrame()
+            .alsoDebug("locations:")
+
+        val gpsList = listOf(
+            Gps(0.0, 0.0),
+            null,
+        )
+        val gps = gpsList
+            .toDataFrame()
+            .alsoDebug("gps:")
+
+        val df1 = listOf(
+            DataSchemaWithAnyFrame(locations),
+        ).toDataFrame()
+            .alsoDebug("df1:")
+
+        df1.convertTo<DataSchemaWithAnyFrame>()
+
+        val df2 = listOf(
+            DataSchemaWithAnyFrame(gps),
+        ).toDataFrame()
+            .alsoDebug("df2:")
+
+        df2.convertTo<DataSchemaWithAnyFrame>()
+
+        val df3 = listOf(
+            DataSchemaWithAnyFrame(null),
+            DataSchemaWithAnyFrame(gps),
+        ).toDataFrame { properties { preserve(DataFrame::class) } }
+            .alsoDebug("df3 before convert:")
+
+        df3.convertTo<DataSchemaWithAnyFrame>()
+
+        val df4 = listOf(
+            DataSchemaWithAnyFrame(null),
+        ).toDataFrame { properties { preserve(DataFrame::class) } }
+            .alsoDebug("df4 before convert:")
+
+        df4.convertTo<DataSchemaWithAnyFrame>()
+
+        val df5a: DataFrame<*> = dataFrameOf(
+            columnOf(locations, gps, null).named("dfs"),
+        ).alsoDebug("df5a:")
+
+        df5a.convertTo<DataSchemaWithAnyFrame>()
+
+        val df5 = listOf(
+            DataSchemaWithAnyFrame(null),
+            DataSchemaWithAnyFrame(locations),
+            DataSchemaWithAnyFrame(gps),
+        ).toDataFrame { properties { preserve(DataFrame::class) } }
+            .alsoDebug("df5 before convert:")
+
+        df5.convertTo<DataSchemaWithAnyFrame>()
+            .alsoDebug("df5 after convert:")
+            .convertTo<DataSchemaWithAnyFrame>()
+            .alsoDebug("df5 after second convert:")
+    }
+
+    interface KeyValue<T> {
+        val key: String
+        val value: T
+    }
+
+    @DataSchema
+    interface MySchema : KeyValue<Int>
+
+    @Test
+    fun `Convert generic interface to itself`() {
+        val df = dataFrameOf("key", "value")(
+            "a", 1,
+            "b", 2,
+        ).alsoDebug()
+        val converted = df.convertTo<MySchema>().alsoDebug()
+        converted shouldBe df
+    }
+
+    @Test
+    fun `convert with missing nullable column`() {
+        @DataSchema
+        data class Result(val a: Int, val b: Int?)
+
+        val df = dataFrameOf("a")(1, 2)
+        val converted = df.convertTo<Result>()
+        converted shouldBe listOf(Result(1, null), Result(2, null)).toDataFrame()
+    }
+
+    @Test
+    fun `convert with custom fill of missing columns`() {
+        val locations = listOf(
+            Location("Home", Gps(1.0, 1.0)),
+            Location("Away", null),
+        ).toDataFrame().cast<Location>()
+
+        val converted = locations
+            .remove { gps.longitude }
+            .cast<Unit>()
+            .convertTo<Location> {
+                fill { gps.longitude }.with { gps.latitude }
+            }
+
+        converted shouldBe locations.update { gps.longitude }.with { gps.latitude }
+    }
+
+    @Test
+    fun `convert column of empty lists into FrameColumn`() {
+        @DataSchema
+        data class Entry(val v: Int)
+
+        @DataSchema
+        data class Result(val d: DataFrame<Entry>)
+
+        dataFrameOf("d")(emptyList<Any>(), emptyList<Any>())
+            .convertTo<Result>() shouldBe
+            dataFrameOf("d")(DataFrame.emptyOf<Entry>(), DataFrame.emptyOf<Entry>())
+    }
+
+    @Test
+    fun `convert ColumnGroup into FrameColumn`() {
+        @DataSchema
+        data class Entry(val v: Int)
+
+        @DataSchema
+        data class Result(val d: DataFrame<Entry>)
+
+        val columnGroup = DataColumn.createColumnGroup("d", dataFrameOf("v")(1, 2))
+        columnGroup.kind() shouldBe ColumnKind.Group
+        val res = dataFrameOf(columnGroup).convertTo<Result>()
+        val frameColumn = res.getFrameColumn("d")
+        frameColumn.kind shouldBe ColumnKind.Frame
+        frameColumn.values() shouldBe listOf(dataFrameOf("v")(1), dataFrameOf("v")(2))
+    }
+
+    @Test
+    fun `convert ValueColumn of lists, nulls and frames into FrameColumn`() {
+        @DataSchema
+        data class Entry(val v: Int)
+
+        @DataSchema
+        data class Result(val d: DataFrame<Entry>)
+
+        val emptyList: List<Any?> = emptyList()
+        val listOfRows: List<AnyRow> = dataFrameOf("v")(1, 2).rows().toList()
+        val frame: DataFrame<Entry> = listOf(Entry(3), Entry(4)).toDataFrame()
+
+        val src = DataColumn.createValueColumn("d", listOf(emptyList, listOfRows, frame, null)).toDataFrame()
+        src["d"].kind shouldBe ColumnKind.Value
+
+        val df = src.convertTo<Result>()
+        val frameColumn = df.getFrameColumn("d")
+        frameColumn.kind shouldBe ColumnKind.Frame
+        frameColumn.toList() shouldBe listOf(
+            DataFrame.emptyOf<Entry>(),
+            dataFrameOf("v")(1, 2),
+            dataFrameOf("v")(3, 4),
+            DataFrame.emptyOf<Entry>(),
+        )
+    }
+}
diff --git a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/corr.kt b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/corr.kt
new file mode 100644
index 000000000..131417c33
--- /dev/null
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/corr.kt
@@ -0,0 +1,58 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import io.kotest.matchers.doubles.ToleranceMatcher
+import io.kotest.matchers.should
+import io.kotest.matchers.shouldBe
+import org.junit.Test
+
+@Suppress("ktlint:standard:argument-list-wrapping")
+class CorrTests {
+
+    val df = dataFrameOf("a", "b", "c")(
+        3, true, 1,
+        6, false, 2,
+    )
+
+    @Test
+    fun `corr with boolean`() {
+        val corr = df.corr("a", "b").with("c")
+        corr.rowsCount() shouldBe 2
+        corr.columnsCount() shouldBe 2
+        corr.getColumn(0) shouldBe (columnOf("a", "b") named "column")
+        corr.getColumn(1).name() shouldBe "c"
+        corr["c"][0] as Double should ToleranceMatcher(1.0, 0.01)
+        corr["c"][1] as Double should ToleranceMatcher(-1.0, 0.01)
+    }
+
+    @Test
+    fun `corr group`() {
+        val corr = df
+            .group("a", "b")
+            .into("g")
+            .corr("g")
+            .with("c")
+
+        corr shouldBe df.corr("a", "b").with("c").rename("column" to "g")
+    }
+
+    @Test
+    fun `corr itself`() {
+        val corr = df.corr()
+        val expected = dataFrameOf("column", "a", "b", "c")(
+            "a", 1.0, -1.0, 1.0,
+            "b", -1.0, 1.0, -1.0,
+            "c", 1.0, -1.0, 1.0,
+        )
+        corr.columns().zip(expected.columns()).forEach { (a, b) ->
+            a.type() shouldBe b.type()
+            if (a.isNumber()) {
+                a.name() shouldBe b.name()
+                a.values().zip(b.values()).forEach { (v1, v2) ->
+                    v1 as Double should ToleranceMatcher(v2 as Double, 0.01)
+                }
+            } else {
+                a shouldBe b
+            }
+        }
+    }
+}
diff --git a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/describe.kt b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/describe.kt
new file mode 100644
index 000000000..a418e8744
--- /dev/null
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/describe.kt
@@ -0,0 +1,14 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import io.kotest.matchers.shouldBe
+import org.junit.Test
+
+class DescribeTests {
+
+    @Test
+    fun `describe all nulls`() {
+        val a by columnOf(1, null)
+        val df = dataFrameOf(a).drop(1)
+        df.describe()["min"][0] shouldBe null
+    }
+}
diff --git a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/distinct.kt b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/distinct.kt
new file mode 100644
index 000000000..0cb9a9226
--- /dev/null
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/distinct.kt
@@ -0,0 +1,56 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import io.kotest.assertions.throwables.shouldThrow
+import io.kotest.matchers.shouldBe
+import org.jetbrains.kotlinx.dataframe.exceptions.DuplicateColumnNamesException
+import org.jetbrains.kotlinx.dataframe.samples.api.age
+import org.jetbrains.kotlinx.dataframe.samples.api.city
+import org.jetbrains.kotlinx.dataframe.samples.api.firstName
+import org.jetbrains.kotlinx.dataframe.samples.api.name
+import org.junit.Test
+
+class DistinctTests : ColumnsSelectionDslTests() {
+
+    @Test
+    fun distinct() {
+        listOf(
+            df.select { all() },
+            df.select { all().distinct() },
+            df.select { (all() and age and city).distinct() },
+        ).shouldAllBeEqual()
+
+        dfGroup.getColumnsWithPaths {
+            cols(
+                name.firstName,
+                name.firstName,
+                name.firstName.firstName,
+            ).distinct()
+        }.let { cols ->
+            cols.size shouldBe 2
+            cols.first().path shouldBe pathOf("name", "firstName")
+            cols.last().path shouldBe pathOf("name", "firstName", "firstName")
+        }
+
+        dfGroup.getColumnsWithPaths {
+            cols(
+                "name"["firstName"],
+                "name"["firstName"],
+                "name"["firstName"]["firstName"],
+            ).distinct()
+        }.let { cols ->
+            cols.size shouldBe 2
+            cols.first().path shouldBe pathOf("name", "firstName")
+            cols.last().path shouldBe pathOf("name", "firstName", "firstName")
+        }
+
+        shouldThrow<DuplicateColumnNamesException> {
+            dfGroup.select {
+                cols(
+                    name.firstName,
+                    name.firstName,
+                    name.firstName.firstName,
+                ).distinct()
+            }
+        }
+    }
+}
diff --git a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/drop.kt b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/drop.kt
new file mode 100644
index 000000000..ecbaaaede
--- /dev/null
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/drop.kt
@@ -0,0 +1,47 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import org.jetbrains.kotlinx.dataframe.samples.api.firstName
+import org.jetbrains.kotlinx.dataframe.samples.api.lastName
+import org.jetbrains.kotlinx.dataframe.samples.api.name
+import org.junit.Test
+
+class DropTests : ColumnsSelectionDslTests() {
+
+    @Test
+    fun `drop and dropLast`() {
+        listOf(
+            df.select { name.lastName },
+            df.select { name.dropCols(1) },
+            df.select { "name".dropCols(1) },
+            df.select { Person::name.dropCols(1) },
+            df.select { pathOf("name").dropCols(1) },
+        ).shouldAllBeEqual()
+
+        listOf(
+            df.select { name.firstName },
+            df.select { name.dropLastCols(1) },
+            df.select { "name".dropLastCols(1) },
+            df.select { Person::name.dropLastCols(1) },
+            df.select { pathOf("name").dropLastCols(1) },
+        ).shouldAllBeEqual()
+    }
+
+    @Test
+    fun `dropWhile and dropLastWhile`() {
+        listOf(
+            df.select { name.lastName },
+            df.select { name.dropColsWhile { it.name == "firstName" } },
+            df.select { "name".dropColsWhile { it.name == "firstName" } },
+            df.select { Person::name.dropColsWhile { it.name == "firstName" } },
+            df.select { pathOf("name").dropColsWhile { it.name == "firstName" } },
+        ).shouldAllBeEqual()
+
+        listOf(
+            df.select { name.firstName },
+            df.select { name.dropLastColsWhile { it.name == "lastName" } },
+            df.select { "name".dropLastColsWhile { it.name == "lastName" } },
+            df.select { Person::name.dropLastColsWhile { it.name == "lastName" } },
+            df.select { pathOf("name").dropLastColsWhile { it.name == "lastName" } },
+        ).shouldAllBeEqual()
+    }
+}
diff --git a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/emptyDataFrame.kt b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/emptyDataFrame.kt
new file mode 100644
index 000000000..6f7d3b33a
--- /dev/null
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/emptyDataFrame.kt
@@ -0,0 +1,52 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import io.kotest.matchers.shouldBe
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.annotations.DataSchema
+import org.junit.Test
+import kotlin.reflect.typeOf
+
+class EmptyDataFrameTests {
+
+    @Test
+    fun simple() {
+        with(DataFrame.empty()) {
+            rowsCount() shouldBe 0
+            columnsCount() shouldBe 0
+        }
+    }
+
+    @Test
+    fun emptyWithRows() {
+        with(DataFrame.empty(3)) {
+            rowsCount() shouldBe 3
+            columnsCount() shouldBe 0
+        }
+    }
+
+    @DataSchema
+    data class FrameSchema(val e: Double)
+
+    @DataSchema
+    data class GroupSchema(val c: Int, val d: String)
+
+    @DataSchema
+    data class Schema(val a: Int, val group: GroupSchema, val frame: List<FrameSchema>)
+
+    @Test
+    fun emptyWithColumns() {
+        with(DataFrame.emptyOf<Schema>()) {
+            rowsCount() shouldBe 0
+            columnsCount() shouldBe 3
+            columnNames() shouldBe listOf("a", "group", "frame")
+            get("a").type() shouldBe typeOf<Int>()
+            getColumnGroup("group").let {
+                it.columnNames() shouldBe listOf("c", "d")
+                it["c"].type() shouldBe typeOf<Int>()
+            }
+            getFrameColumn("frame").let {
+                it.schema.value.columns.keys shouldBe listOf("e")
+            }
+        }
+    }
+}
diff --git a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/explode.kt b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/explode.kt
new file mode 100644
index 000000000..cd9835794
--- /dev/null
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/explode.kt
@@ -0,0 +1,47 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import io.kotest.matchers.shouldBe
+import org.junit.Test
+
+@Suppress("ktlint:standard:argument-list-wrapping")
+class ExplodeTests {
+
+    @Test
+    fun `explode into`() {
+        val df = dataFrameOf("a" to listOf(1), "b" to listOf(listOf(2, 3)))
+        val exploded = df.explode { "b" into "c" }
+        val expected = dataFrameOf("a" to listOf(1, 1), "c" to listOf(2, 3))
+        exploded shouldBe expected
+    }
+
+    @Test
+    fun `explode list and duplicate value`() {
+        val exploded = dataFrameOf(
+            "a", "b",
+        )(
+            1, listOf(2, 3),
+        ).explode()
+        exploded shouldBe dataFrameOf("a", "b")(1, 2, 1, 3)
+    }
+
+    @Test
+    fun `explode list and frame column`() {
+        val exploded = dataFrameOf(
+            "a", "b", "c", "d",
+        )(
+            1, listOf(2, 3), dataFrameOf("x", "y")(4, 5, 6, 7), listOf(8),
+        )
+            .explode()
+            .ungroup("c")
+        exploded shouldBe dataFrameOf("a", "b", "x", "y", "d")(
+            1, 2, 4, 5, 8,
+            1, 3, 6, 7, null,
+        )
+    }
+
+    @Test
+    fun `explode nothing`() {
+        val df = dataFrameOf("a", "b")(1, 2)
+        df.explode() shouldBe df
+    }
+}
diff --git a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/expr.kt b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/expr.kt
new file mode 100644
index 000000000..8679bfcaa
--- /dev/null
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/expr.kt
@@ -0,0 +1,46 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import io.kotest.matchers.shouldBe
+import org.jetbrains.kotlinx.dataframe.samples.api.age
+import org.junit.Test
+import kotlin.reflect.typeOf
+
+class ExprTests : ColumnsSelectionDslTests() {
+
+    @Test
+    fun expr() {
+        listOf(
+            df.select { age },
+            df.select { expr(age.name) { age } },
+            df.select { expr { age } named age },
+            df.select { mapToColumn(age) { age } },
+        ).shouldAllBeEqual()
+
+        df
+            .get {
+                expr("fibonacci") {
+                    if (index() < 2) {
+                        1
+                    } else {
+                        prev()!!.newValue<Int>() + prev()!!.prev()!!.newValue<Int>()
+                    }
+                }
+            }.toList() shouldBe listOf(1, 1, 2, 3, 5, 8, 13)
+
+        df.select {
+            expr<_, Int?>(infer = Infer.None) { 1 }.type() shouldBe typeOf<Int?>()
+            expr<_, Int>(infer = Infer.None) { 1 }.type() shouldBe typeOf<Int>()
+            expr<_, Any?>(infer = Infer.None) { 1 }.type() shouldBe typeOf<Any?>()
+
+            expr<_, Int?>(infer = Infer.Nulls) { 1 }.type() shouldBe typeOf<Int>()
+            expr<_, Int>(infer = Infer.Nulls) { 1 }.type() shouldBe typeOf<Int>()
+            expr<_, Any?>(infer = Infer.Nulls) { 1 }.type() shouldBe typeOf<Any>()
+
+            expr<_, Int?>(infer = Infer.Type) { 1 }.type() shouldBe typeOf<Int>()
+            expr<_, Int>(infer = Infer.Type) { 1 }.type() shouldBe typeOf<Int>()
+            expr<_, Any?>(infer = Infer.Type) { 1 }.type() shouldBe typeOf<Int>()
+
+            none()
+        }
+    }
+}
diff --git a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/filter.kt b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/filter.kt
new file mode 100644
index 000000000..009f44a13
--- /dev/null
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/filter.kt
@@ -0,0 +1,22 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import io.kotest.matchers.shouldBe
+import org.jetbrains.kotlinx.dataframe.samples.api.age
+import org.jetbrains.kotlinx.dataframe.samples.api.name
+import org.jetbrains.kotlinx.dataframe.samples.api.weight
+import org.junit.Test
+
+class FilterTests : ColumnsSelectionDslTests() {
+
+    @Test
+    fun `filter`() {
+        listOf(
+            df.select { cols(name, age, weight) },
+            df.select { all().filter { "e" in it.name() } },
+            df.select { all().cols { "e" in it.name() } },
+        ).shouldAllBeEqual()
+
+        df.select { all().filter { true } } shouldBe df.select { all() }
+        df.select { all().filter { false } } shouldBe df.select { none() }
+    }
+}
diff --git a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/first.kt b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/first.kt
new file mode 100644
index 000000000..c52ceab21
--- /dev/null
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/first.kt
@@ -0,0 +1,43 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import io.kotest.assertions.throwables.shouldThrow
+import org.jetbrains.kotlinx.dataframe.samples.api.firstName
+import org.jetbrains.kotlinx.dataframe.samples.api.name
+import org.junit.Test
+
+class FirstTests : ColumnsSelectionDslTests() {
+
+    @Test
+    fun `ColumnsSelectionDsl first`() {
+        shouldThrow<IllegalArgumentException> {
+            df.select { "age".firstCol() }
+        }
+        shouldThrow<IllegalArgumentException> {
+            df.select { columnGroup(Person::age).firstCol() }
+        }
+        shouldThrow<IllegalArgumentException> {
+            df.select { Person::age.firstCol() }
+        }
+        shouldThrow<NoSuchElementException> {
+            df.select { first { false } }
+        }
+
+        listOf(
+            df.select { name },
+            df.select { first() },
+            df.select { all().first() },
+            df.select { first { it.name().startsWith("n") } },
+        ).shouldAllBeEqual()
+
+        listOf(
+            df.select { name.firstName },
+            df.select { name.colsOf<String>().first { col -> col.any { it == "Alice" } } },
+            df.select { name.firstCol { col -> col.any { it == "Alice" } } },
+            df.select { "name".firstCol { col -> col.any { it == "Alice" } } },
+            df.select { Person::name.firstCol { col -> col.any { it == "Alice" } } },
+            df.select { NonDataSchemaPerson::name.firstCol { col -> col.any { it == "Alice" } } },
+            df.select { pathOf("name").firstCol { col -> col.any { it == "Alice" } } },
+            df.select { it["name"].asColumnGroup().firstCol { col -> col.any { it == "Alice" } } },
+        ).shouldAllBeEqual()
+    }
+}
diff --git a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/frameCol.kt b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/frameCol.kt
new file mode 100644
index 000000000..3645a6568
--- /dev/null
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/frameCol.kt
@@ -0,0 +1,109 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import io.kotest.assertions.throwables.shouldThrow
+import org.jetbrains.kotlinx.dataframe.samples.api.name
+import org.junit.Test
+
+class FrameColTests : ColumnsSelectionDslTests() {
+
+    @Test
+    fun `frameCol exceptions`() {
+        shouldThrow<IllegalArgumentException> {
+            dfWithFrames.select { frameCol("name") }
+        }
+        shouldThrow<IllegalStateException> {
+            dfWithFrames.select { frameCol("nonExisting") }
+        }
+        shouldThrow<IllegalStateException> {
+            dfWithFrames.select { name.frameCol("nonExisting") }
+        }
+        shouldThrow<IllegalStateException> {
+            dfWithFrames.select { "age".frameCol("test") }
+        }
+        shouldThrow<IndexOutOfBoundsException> {
+            dfWithFrames.select { frameCol(100) }
+        }
+    }
+
+    @Test
+    fun `frameCol at top-level`() {
+        listOf(
+            dfWithFrames.select { frameCol },
+            dfWithFrames.select { frameCol(frameCol) },
+            dfWithFrames.select { frameCol("frameCol") },
+            dfWithFrames.select { frameCol<Person>("frameCol") },
+            dfWithFrames.select { frameCol(pathOf("frameCol")) },
+            dfWithFrames.select { frameCol<Person>(pathOf("frameCol")) },
+            dfWithFrames.select { frameCol(PersonWithFrame::frameCol) },
+            dfWithFrames.select { frameCols().frameCol(0) },
+            dfWithFrames.select { all().frameCol(5) },
+            dfWithFrames.select { frameCol(5) },
+            dfWithFrames.select { frameCol<Person>(5) },
+        ).shouldAllBeEqual()
+    }
+
+    @Test
+    fun `frameCol at lower level`() {
+        val frameColAccessor = frameCol
+        listOf(
+            dfWithFrames.select { name[frameCol] },
+            // reference
+            dfWithFrames.select { name.frameCol(frameColAccessor) },
+            dfWithFrames.select { colGroup("name").frameCol(frameColAccessor) },
+            dfWithFrames.select { "name".frameCol(frameColAccessor) },
+            dfWithFrames.select { NonDataSchemaPerson::name.frameCol(frameColAccessor) },
+            dfWithFrames.select { Person::name.frameCol(frameColAccessor) },
+            dfWithFrames.select { pathOf("name").frameCol(frameColAccessor) },
+            // name
+            dfWithFrames.select { name.frameCol("frameCol") },
+            dfWithFrames.select { name.frameCol<Person>("frameCol") },
+            dfWithFrames.select { colGroup("name").frameCol("frameCol") },
+            dfWithFrames.select { colGroup("name").frameCol<Person>("frameCol") },
+            dfWithFrames.select { "name".frameCol("frameCol") },
+            dfWithFrames.select { "name".frameCol<Person>("frameCol") },
+            dfWithFrames.select { NonDataSchemaPerson::name.frameCol("frameCol") },
+            dfWithFrames.select { NonDataSchemaPerson::name.frameCol<Person>("frameCol") },
+            dfWithFrames.select { Person::name.frameCol("frameCol") },
+            dfWithFrames.select { Person::name.frameCol<Person>("frameCol") },
+            dfWithFrames.select { pathOf("name").frameCol("frameCol") },
+            dfWithFrames.select { pathOf("name").frameCol<Person>("frameCol") },
+            // path
+            dfWithFrames.select { name.frameCol(pathOf("frameCol")) },
+            dfWithFrames.select { name.frameCol<Person>(pathOf("frameCol")) },
+            dfWithFrames.select { colGroup("name").frameCol(pathOf("frameCol")) },
+            dfWithFrames.select { colGroup("name").frameCol<Person>(pathOf("frameCol")) },
+            dfWithFrames.select { "name".frameCol(pathOf("frameCol")) },
+            dfWithFrames.select { "name".frameCol<Person>(pathOf("frameCol")) },
+            dfWithFrames.select { NonDataSchemaPerson::name.frameCol(pathOf("frameCol")) },
+            dfWithFrames.select { NonDataSchemaPerson::name.frameCol<Person>(pathOf("frameCol")) },
+            dfWithFrames.select { Person::name.frameCol(pathOf("frameCol")) },
+            dfWithFrames.select { Person::name.frameCol<Person>(pathOf("frameCol")) },
+            dfWithFrames.select { pathOf("name").frameCol(pathOf("frameCol")) },
+            dfWithFrames.select { pathOf("name").frameCol<Person>(pathOf("frameCol")) },
+            dfWithFrames.select { frameCol("name"["frameCol"]) },
+            dfWithFrames.select { frameCol<Person>("name"["frameCol"]) },
+            dfWithFrames.select { asSingleColumn().frameCol("name"["frameCol"]) },
+            dfWithFrames.select { asSingleColumn().frameCol<Person>("name"["frameCol"]) },
+            // property
+            dfWithFrames.select { name.frameCol(PersonWithFrame::frameCol) },
+            dfWithFrames.select { colGroup("name").frameCol(PersonWithFrame::frameCol) },
+            dfWithFrames.select { "name".frameCol(PersonWithFrame::frameCol) },
+            dfWithFrames.select { NonDataSchemaPerson::name.frameCol(PersonWithFrame::frameCol) },
+            dfWithFrames.select { Person::name.frameCol(PersonWithFrame::frameCol) },
+            dfWithFrames.select { pathOf("name").frameCol(PersonWithFrame::frameCol) },
+            // index
+            dfWithFrames.select { name.frameCol(2) },
+            dfWithFrames.select { name.frameCol<Person>(2) },
+            dfWithFrames.select { colGroup("name").frameCol(2) },
+            dfWithFrames.select { colGroup("name").frameCol<Person>(2) },
+            dfWithFrames.select { "name".frameCol(2) },
+            dfWithFrames.select { "name".frameCol<Person>(2) },
+            dfWithFrames.select { NonDataSchemaPerson::name.frameCol(2) },
+            dfWithFrames.select { NonDataSchemaPerson::name.frameCol<Person>(2) },
+            dfWithFrames.select { Person::name.frameCol(2) },
+            dfWithFrames.select { Person::name.frameCol<Person>(2) },
+            dfWithFrames.select { pathOf("name").frameCol(2) },
+            dfWithFrames.select { pathOf("name").frameCol<Person>(2) },
+        ).shouldAllBeEqual()
+    }
+}
diff --git a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/frameCols.kt b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/frameCols.kt
new file mode 100644
index 000000000..8ce99ae7d
--- /dev/null
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/frameCols.kt
@@ -0,0 +1,53 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import io.kotest.assertions.throwables.shouldThrow
+import org.jetbrains.kotlinx.dataframe.AnyFrame
+import org.jetbrains.kotlinx.dataframe.samples.api.name
+import org.junit.Test
+
+class FrameColsTests : ColumnsSelectionDslTests() {
+
+    @Test
+    fun `frameCols exceptions`() {
+        shouldThrow<IllegalArgumentException> {
+            df.select { "age".frameCols() }
+        }
+    }
+
+    @Test
+    fun `frameCols at top-level`() {
+        listOf(
+            dfWithFrames.select { frameCol },
+            dfWithFrames.select { all().frameCols() },
+            dfWithFrames.select { frameCols() },
+        ).shouldAllBeEqual()
+
+        listOf(
+            dfWithFrames.select { name[frameCol] },
+            dfWithFrames.select { name[frameCol] }.select { all() },
+            dfWithFrames.select { name[frameCol] }.select { frameCols() },
+            dfWithFrames.select { name[frameCol] }.select { frameCols().all() },
+            dfWithFrames.select { name[frameCol] }.select { all().frameCols() },
+        ).shouldAllBeEqual()
+
+        listOf(
+            dfWithFrames.select { frameCol },
+            dfWithFrames.select { frameCols { "e" in it.name() } },
+            dfWithFrames.select { all().frameCols { "e" in it.name() } },
+        ).shouldAllBeEqual()
+    }
+
+    @Test
+    fun `frameCols at lower level`() {
+        listOf(
+            dfWithFrames.select { name[frameCol] },
+            dfWithFrames.select { name.frameCols { "frame" in it.name() } },
+            dfWithFrames.select { name.colsOf<AnyFrame> { "frame" in it.name() } },
+            dfWithFrames.select { name.colsOf<AnyFrame>().frameCols { "frame" in it.name() } },
+            dfWithFrames.select { "name".frameCols { "frame" in it.name() } },
+            dfWithFrames.select { Person::name.frameCols { "frame" in it.name() } },
+            dfWithFrames.select { pathOf("name").frameCols { "frame" in it.name() } },
+            dfWithFrames.select { it["name"].asColumnGroup().frameCols { "frame" in it.name() } },
+        ).shouldAllBeEqual()
+    }
+}
diff --git a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/gather.kt b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/gather.kt
new file mode 100644
index 000000000..3925885b6
--- /dev/null
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/gather.kt
@@ -0,0 +1,190 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import io.kotest.matchers.shouldBe
+import org.intellij.lang.annotations.Language
+import org.jetbrains.kotlinx.dataframe.AnyFrame
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.DataRow
+import org.jetbrains.kotlinx.dataframe.annotations.DataSchema
+import org.jetbrains.kotlinx.dataframe.columns.ColumnKind
+import org.jetbrains.kotlinx.dataframe.io.readJsonStr
+import org.jetbrains.kotlinx.dataframe.kind
+import org.junit.Test
+import kotlin.reflect.typeOf
+
+@Suppress("ktlint:standard:argument-list-wrapping")
+class GatherTests {
+
+    //region Data Source
+
+    @Language("json")
+    val df = """
+            [
+                {
+                    "name": "abc",
+                    "normal": {
+                        "c1": "a",
+                        "c2": "b",
+                        "c3": "c"
+                    },
+                    "reversed": {
+                        "c1": "c",
+                        "c2": "b",
+                        "c3": "a"
+                    },
+                    "first": {
+                        "c1": "c"
+                    }
+                },
+                {
+                    "name": "qw",
+                    "normal": {
+                        "c1": "q",
+                        "c2": "w"
+                    },
+                    "reversed": {
+                        "c1": "w",
+                        "c2": "q"
+                    },
+                    "first": {
+                        "c1": "q"
+                    }
+                }
+            ]
+        """.let {
+        DataFrame.readJsonStr(it)
+    }
+
+    //endregion
+
+    val generatedCode = df.generateCode("Marker")
+
+    //region Generated code
+
+    @DataSchema(isOpen = false)
+    interface Marker1 {
+        val c1: String
+        val c2: String
+        val c3: String?
+    }
+
+    @DataSchema(isOpen = false)
+    interface Marker2 {
+        val c1: String
+        val c2: String
+        val c3: String?
+    }
+
+    @DataSchema(isOpen = false)
+    interface Marker3 {
+        val c1: String
+    }
+
+    @DataSchema
+    interface Marker {
+        val name: String
+        val normal: DataRow<Marker1>
+        val reversed: DataRow<Marker2>
+        val first: DataRow<Marker3>
+    }
+
+    //endregion
+
+    val typed = df.cast<Marker>()
+
+    @Test
+    fun gather() {
+        val mode by column<String>()
+        val temp by column<String>()
+        val gathered = typed
+            .gather { allExcept(name) }.cast<String>().into(mode, temp)
+            .ungroup(temp)
+
+        val expected = typed
+            .groupBy { name }.updateGroups {
+                val cols = columns().drop(1).map { it.asColumnGroup() } // drop 'name' column
+                val dataRows = cols.map { it[0] }
+
+                val newDf = listOf(
+                    name.withValues(List(cols.size) { name[0] }),
+                    mode.withValues(cols.map { it.name() }),
+                    dataRows.map { it.getValueOrNull<String>("c1") }.toColumn("c1"),
+                    dataRows.map { it.getValueOrNull<String>("c2") }.toColumn("c2"),
+                    dataRows.map { it.getValueOrNull<String>("c3") }.toColumn("c3"),
+                ).toDataFrame()
+
+                newDf
+            }.concat()
+
+        gathered shouldBe expected
+    }
+
+    @Test
+    fun `generated code is fully typed`() {
+        generatedCode.value.contains("<*>") shouldBe false
+    }
+
+    @Test
+    fun `gather column group`() {
+        val java by columnOf(1, 2, 3)
+        val kotlin by columnOf(1, 2, 3)
+        val languages by column<DataRow<Unit>>()
+
+        val df = dataFrameOf(java, kotlin).group { java and kotlin }.into("languages")
+
+        fun AnyFrame.check() {
+            this["value"].kind shouldBe ColumnKind.Group
+            columnsCount() shouldBe 2
+            rowsCount() shouldBe 3
+        }
+
+        df.gather { languages }.into("key", "value").check()
+    }
+
+    @Test
+    fun `gather mix of columns`() {
+        val a by columnOf(1, 1.1)
+        val b by columnOf(2, 2.2)
+
+        val df = dataFrameOf(a, b)[0..0]
+
+        val gathered = df
+            .gather { a and b }
+            .into("key", "value")
+
+        gathered["value"].type() shouldBe typeOf<Int>()
+    }
+
+    @Test
+    fun `gather values`() {
+        val a by columnOf(1, 2)
+        val b by columnOf(3, 4)
+
+        var df = dataFrameOf(a, b).gather { a and b }.valuesInto("data")
+        df.columnsCount() shouldBe 1
+        df["data"].values() shouldBe listOf(1, 3, 2, 4)
+
+        df = dataFrameOf(a, b).gather { a and b }.where { it % 2 == 1 }.valuesInto("data")
+        df.columnsCount() shouldBe 1
+        df["data"].values() shouldBe listOf(1, 3)
+    }
+
+    @Test
+    fun `gather explode lists`() {
+        val a by columnOf(1, 2)
+        val b by columnOf(listOf(3, 4), listOf(5, 6))
+
+        val df = dataFrameOf(a, b)
+            .gather { a and b }
+            .explodeLists()
+            .cast<Int>()
+            .where { it % 2 == 1 }
+            .into("key", "value")
+
+        df shouldBe dataFrameOf("key", "value")(
+            "a", 1,
+            "b", 3,
+            "b", 5,
+        )
+    }
+}
diff --git a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/get.kt b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/get.kt
new file mode 100644
index 000000000..5117b1868
--- /dev/null
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/get.kt
@@ -0,0 +1,102 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import io.kotest.assertions.throwables.shouldThrow
+import io.kotest.assertions.throwables.shouldThrowAny
+import io.kotest.matchers.shouldBe
+import io.kotest.matchers.string.shouldContain
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.annotations.DataSchema
+import org.junit.Test
+import java.lang.ClassCastException
+import java.lang.IllegalArgumentException
+
+class GetTests {
+
+    @Test
+    fun `exceptions from empty dataframe`() {
+        val empty = DataFrame.empty()
+        shouldThrow<NoSuchElementException> {
+            empty.first()
+        }
+        shouldThrow<NoSuchElementException> {
+            empty.last()
+        }
+        shouldThrow<IndexOutOfBoundsException> {
+            empty[0]
+        }
+    }
+
+    @Test
+    fun `get value from row`() {
+        val a by column<Int>()
+        val c by column<Int>()
+
+        data class A(val a: Int, val b: Int, val c: Int)
+
+        val df = dataFrameOf("a", "b")(1, 2)
+        val row = df[0]
+
+        row["a"] shouldBe 1
+        row.getValue<Int>("a") shouldBe 1
+        row.getValue(a) shouldBe 1
+        row.getValue(A::a) shouldBe 1
+
+        row.getValueOrNull<Int>("c") shouldBe null
+        row.getValueOrNull(c) shouldBe null
+        row.getValueOrNull(A::c) shouldBe null
+
+        shouldThrow<IllegalArgumentException> { row.getValue<Int>("c") }
+        shouldThrow<IllegalArgumentException> { row.getValue(c) }
+        shouldThrow<IllegalArgumentException> { row.getValue(A::c) }
+
+        val added = df.add(A::c) { "3" }[0]
+
+        shouldThrow<ClassCastException> { added.getValue(c) + 1 }
+        shouldThrow<ClassCastException> { added.getValue<Int>("c") + 1 }
+        shouldThrow<ClassCastException> { added.getValue(A::c) + 1 }
+    }
+
+    @DataSchema
+    data class Schema(val a: Int)
+
+    @Test
+    fun `create typed frame column accessor`() {
+        val df = dataFrameOf(
+            columnOf(
+                dataFrameOf("a")(1),
+                dataFrameOf("a", "b")(
+                    2,
+                    3,
+                    4,
+                    5,
+                ),
+            ).named("x"),
+        )
+        val x by frameColumn<Schema>()
+        df[x][0].a[0] shouldBe 1
+        df[1][x].a[1] shouldBe 4
+    }
+
+    @Test
+    @Suppress("ktlint:standard:argument-list-wrapping")
+    fun `create typed column group accessor`() {
+        val df = dataFrameOf(
+            dataFrameOf("a", "b")(
+                1, 2,
+                3, 4,
+            ).asColumnGroup("x"),
+        )
+        val x by columnGroup<Schema>()
+        df[x][0].a shouldBe 1
+        df[1][x].a shouldBe 3
+    }
+
+    @Test
+    fun `throw meaningful exception when traverse columns in DataRow`() {
+        val df = dataFrameOf("a")(null)
+        val throwable = shouldThrowAny {
+            df[0].getColumnGroup("a")
+        }
+        throwable.message shouldContain "Cannot cast null value of a ValueColumn to"
+    }
+}
diff --git a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/groupBy.kt b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/groupBy.kt
new file mode 100644
index 000000000..2632a649b
--- /dev/null
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/groupBy.kt
@@ -0,0 +1,59 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import io.kotest.matchers.shouldBe
+import org.jetbrains.kotlinx.dataframe.AnyFrame
+import org.junit.Test
+import kotlin.reflect.typeOf
+
+@Suppress("ktlint:standard:argument-list-wrapping")
+class GroupByTests {
+
+    @Test
+    fun `groupBy values with nulls`() {
+        val df = dataFrameOf(
+            "a", "b",
+        )(
+            1, 1,
+            1, null,
+            2, null,
+            3, 1,
+        )
+
+        df.groupBy("a").values { "b" into "c" } shouldBe
+            dataFrameOf(
+                "a", "c",
+            )(
+                1, listOf(1, null),
+                2, listOf(null),
+                3, listOf(1),
+            )
+
+        df.groupBy("a").values(dropNA = true) { "b" into "c" } shouldBe
+            dataFrameOf(
+                "a", "c",
+            )(
+                1, listOf(1),
+                2, emptyList<Int>(),
+                3, listOf(1),
+            )
+    }
+
+    @Test
+    fun `aggregate FrameColumns into new column`() {
+        val df = dataFrameOf(
+            "a", "b", "c",
+        )(
+            1, 2, 3,
+            4, 5, 6,
+        )
+        val grouped = df.groupBy("a", "b").into("d")
+
+        grouped.groupBy("a").aggregate {
+            getColumn("d") into "e"
+        }["e"].type() shouldBe typeOf<List<AnyFrame>>()
+
+        grouped.groupBy("a").aggregate {
+            getFrameColumn("d") into "e"
+        }["e"].type() shouldBe typeOf<List<AnyFrame>>()
+    }
+}
diff --git a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/implode.kt b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/implode.kt
new file mode 100644
index 000000000..c9ff8e689
--- /dev/null
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/implode.kt
@@ -0,0 +1,21 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import io.kotest.matchers.shouldBe
+import org.junit.Test
+
+class ImplodeTests {
+
+    @Test
+    fun `implode into`() {
+        val df = dataFrameOf("a" to listOf(1, 1), "b" to listOf(2, 3))
+        val imploded = df.implode { "b" into "c" }
+        val expected = dataFrameOf("a" to listOf(1), "c" to listOf(listOf(2, 3)))
+        imploded shouldBe expected
+    }
+
+    @Test
+    fun `implode all`() {
+        val df = dataFrameOf("a" to listOf(1, 1), "b" to listOf(2, 3))
+        df.implode() shouldBe df.implode { all() }[0]
+    }
+}
diff --git a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/inferType.kt b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/inferType.kt
new file mode 100644
index 000000000..36dde5ad8
--- /dev/null
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/inferType.kt
@@ -0,0 +1,32 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import io.kotest.matchers.shouldBe
+import org.junit.Test
+import kotlin.reflect.typeOf
+
+class InferTypeTests {
+
+    @Test
+    fun `infer type 1`() {
+        val col by columnOf("Alice", 1, 3.5)
+        col.type() shouldBe typeOf<Comparable<*>>()
+        val filtered = col.filter { it is String }
+        filtered.type() shouldBe typeOf<Comparable<*>>()
+        filtered.inferType().type() shouldBe typeOf<String>()
+    }
+
+    open class A<T>(val value: T)
+
+    class B<T>(value: T) : A<T>(value)
+
+    @Test
+    fun `infer type with argument`() {
+        val col by columnOf(1)
+        val df = dataFrameOf(col)
+        val converted = df.convert(col).with(Infer.None) {
+            B(it) as A<Int>
+        }
+        converted[col].type() shouldBe typeOf<A<Int>>()
+        converted.inferType(col)[col].type() shouldBe typeOf<B<Int>>()
+    }
+}
diff --git a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/join.kt b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/join.kt
new file mode 100644
index 000000000..7b1a4491c
--- /dev/null
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/join.kt
@@ -0,0 +1,34 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import io.kotest.matchers.nulls.shouldNotBeNull
+import io.kotest.matchers.shouldBe
+import org.jetbrains.kotlinx.dataframe.columns.ColumnKind
+import org.jetbrains.kotlinx.dataframe.impl.columns.asAnyFrameColumn
+import org.junit.Ignore
+import org.junit.Test
+
+@Suppress("ktlint:standard:argument-list-wrapping")
+class JoinTests {
+
+    @Ignore
+    @Test
+    fun `left join frame column`() {
+        val df1 = dataFrameOf("a")(1, 2)
+        val df2 = dataFrameOf("a", "b")(
+            1, dataFrameOf("c")(3),
+            4, dataFrameOf("c")(5),
+        )
+        val df = df1.leftJoin(df2)
+
+        df.rowsCount() shouldBe 2
+        df.columnNames() shouldBe listOf("a", "b")
+        df["a"] shouldBe df1["a"]
+        val b = df["b"]
+        b.kind() shouldBe ColumnKind.Frame
+        b.hasNulls() shouldBe false
+        val f = b.asAnyFrameColumn()
+        f[0] shouldBe df2["b"][0]
+        f[1].shouldNotBeNull()
+        f[1].isEmpty() shouldBe true
+    }
+}
diff --git a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/last.kt b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/last.kt
new file mode 100644
index 000000000..dece2355f
--- /dev/null
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/last.kt
@@ -0,0 +1,43 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import io.kotest.assertions.throwables.shouldThrow
+import org.jetbrains.kotlinx.dataframe.samples.api.firstName
+import org.jetbrains.kotlinx.dataframe.samples.api.isHappy
+import org.jetbrains.kotlinx.dataframe.samples.api.name
+import org.junit.Test
+
+class LastTests : ColumnsSelectionDslTests() {
+    @Test
+    fun `ColumnsSelectionDsl last`() {
+        shouldThrow<IllegalArgumentException> {
+            df.select { "age".lastCol() }
+        }
+        shouldThrow<IllegalArgumentException> {
+            df.select { columnGroup(Person::age).lastCol() }
+        }
+        shouldThrow<IllegalArgumentException> {
+            df.select { Person::age.lastCol() }
+        }
+        shouldThrow<NoSuchElementException> {
+            df.select { last { false } }
+        }
+
+        listOf(
+            df.select { isHappy },
+            df.select { last() },
+            df.select { all().last() },
+            df.select { last { it.name().startsWith("is") } },
+        ).shouldAllBeEqual()
+
+        listOf(
+            df.select { name.firstName },
+            df.select { name.colsOf<String>().last { col -> col.any { it == "Alice" } } },
+            df.select { name.lastCol { col -> col.any { it == "Alice" } } },
+            df.select { "name".lastCol { col -> col.any { it == "Alice" } } },
+            df.select { Person::name.lastCol { col -> col.any { it == "Alice" } } },
+            df.select { NonDataSchemaPerson::name.lastCol { col -> col.any { it == "Alice" } } },
+            df.select { pathOf("name").lastCol { col -> col.any { it == "Alice" } } },
+            df.select { it["name"].asColumnGroup().lastCol { col -> col.any { it == "Alice" } } },
+        ).shouldAllBeEqual()
+    }
+}
diff --git a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/map.kt b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/map.kt
new file mode 100644
index 000000000..4f9046b46
--- /dev/null
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/map.kt
@@ -0,0 +1,21 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import io.kotest.matchers.shouldBe
+import org.junit.Test
+
+class MapTests {
+
+    @Test
+    fun `map frame column with empty frames`() {
+        val frames by columnOf(dataFrameOf("a")(1), emptyDataFrame())
+        frames.map { it.firstOrNull() }.size() shouldBe frames.size()
+    }
+
+    @Test
+    fun `map ColumnsContainer`() {
+        val df = dataFrameOf("a")(1, 2).add {
+            expr { "a"<Int>() + 1 }.cumSum() into "b"
+        }
+        df["b"][1] shouldBe 5
+    }
+}
diff --git a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/move.kt b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/move.kt
new file mode 100644
index 000000000..66a368144
--- /dev/null
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/move.kt
@@ -0,0 +1,94 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import io.kotest.assertions.throwables.shouldNotThrowAny
+import io.kotest.matchers.shouldBe
+import org.jetbrains.kotlinx.dataframe.columns.toColumnSet
+import org.junit.Test
+
+class MoveTests {
+
+    val columnNames = listOf("q", "a.b", "b.c", "w", "a.c.d", "e.f", "b.d", "r")
+    val columns = columnNames.map { emptyList<Int>().toColumn(it) }
+    val df = columns.toDataFrame()
+    val grouped = df.move { cols { it.name.contains(".") } }.into { it.name.split(".").toPath() }
+
+    @Test
+    fun `batch grouping`() {
+        grouped.columnNames() shouldBe listOf("q", "a", "b", "w", "e", "r")
+        grouped["a"].asColumnGroup().columnNames() shouldBe listOf("b", "c")
+        grouped["a"]["c"].asColumnGroup().columnNames() shouldBe listOf("d")
+        grouped["b"].asColumnGroup().columnNames() shouldBe listOf("c", "d")
+        grouped["e"].asColumnGroup().columnNames() shouldBe listOf("f")
+    }
+
+    @Test
+    fun `select all`() {
+        grouped.getColumnsWithPaths { all() }.map { it.path.joinToString(".") } shouldBe grouped.columnNames()
+    }
+
+    @Test
+    fun `select all atAnyDepth`() {
+        val selected = grouped
+            .getColumnsWithPaths { colGroups().colsAtAnyDepth { !it.isColumnGroup() } }
+            .map { it.path.joinToString(".") }
+        selected shouldBe listOf("a.b", "a.c.d", "b.c", "b.d", "e.f")
+    }
+
+    @Test
+    fun `batch ungrouping`() {
+        val ungrouped = grouped.move {
+            colsAtAnyDepth { it.depth() > 0 && !it.isColumnGroup() }
+        }.into { pathOf(it.path.joinToString(".")) }
+        ungrouped.columnNames() shouldBe listOf("q", "a.b", "a.c.d", "b.c", "b.d", "w", "e.f", "r")
+    }
+
+    @Test
+    fun `ungroup one`() {
+        val ungrouped = grouped.remove("b").ungroup { it["a"] }
+        ungrouped.columnNames() shouldBe listOf("q", "b", "c", "w", "e", "r")
+        ungrouped["c"].asColumnGroup().columnNames() shouldBe listOf("d")
+    }
+
+    @Test
+    fun `flatten one`() {
+        val flattened = grouped.flatten { it["a"] }
+        flattened.columnNames() shouldBe listOf("q", "b1", "d", "b", "w", "e", "r")
+    }
+
+    @Test
+    fun `flatten several`() {
+        val flattened = grouped.flatten { it["a"]["c"] and it["a"] and it["b"] }
+        flattened.columnNames() shouldBe listOf("q", "b", "d", "c", "d1", "w", "e", "r")
+    }
+
+    @Test
+    fun `flatten all`() {
+        val flattened = grouped.flatten()
+        flattened.columnNames() shouldBe listOf("q", "b", "d", "c", "d1", "w", "f", "r")
+    }
+
+    @Test
+    fun `select recursively`() {
+        val selected = grouped.select {
+            it["a"].asColumnGroup().colsAtAnyDepth { !it.isColumnGroup() }
+        }
+        selected.columnNames() shouldBe listOf("b", "d")
+    }
+
+    @Test
+    fun `columnsWithPath in selector`() {
+        val selected = grouped.getColumnsWithPaths { it["a"] }
+        val actual = grouped.getColumnsWithPaths {
+            selected.map { it.asColumnGroup().colsAtAnyDepth { !it.isColumnGroup() } }.toColumnSet()
+        }
+        actual.map { it.path.joinToString(".") } shouldBe listOf("a.b", "a.c.d")
+    }
+
+    @Test
+    fun `move after last`() {
+        val df = dataFrameOf("1", "2")(1, 2)
+        shouldNotThrowAny {
+            df.move("1").after("2") shouldBe dataFrameOf("2", "1")(2, 1)
+        }
+    }
+}
diff --git a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/none.kt b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/none.kt
new file mode 100644
index 000000000..9c6bb19f6
--- /dev/null
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/none.kt
@@ -0,0 +1,25 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import io.kotest.matchers.shouldBe
+import org.jetbrains.kotlinx.dataframe.ncol
+import org.jetbrains.kotlinx.dataframe.nrow
+import org.jetbrains.kotlinx.dataframe.samples.api.age
+import org.jetbrains.kotlinx.dataframe.samples.api.name
+import org.junit.Test
+
+class NoneTests : ColumnsSelectionDslTests() {
+
+    @Test
+    fun none() {
+        df.select { none() }.let {
+            it.nrow shouldBe 0
+            it.ncol shouldBe 0
+        }
+
+        listOf(
+            df.select { none() and age },
+            df.select { age },
+            df.select { name.select { none() } and age },
+        ).shouldAllBeEqual()
+    }
+}
diff --git a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/parse.kt b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/parse.kt
new file mode 100644
index 000000000..081e28d07
--- /dev/null
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/parse.kt
@@ -0,0 +1,496 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import io.kotest.matchers.should
+import io.kotest.matchers.shouldBe
+import kotlinx.datetime.DateTimeUnit
+import kotlinx.datetime.Instant
+import kotlinx.datetime.LocalDate
+import kotlinx.datetime.LocalDateTime
+import kotlinx.datetime.LocalTime
+import kotlinx.datetime.Month
+import kotlinx.datetime.format.DateTimeComponents
+import kotlinx.datetime.plus
+import kotlinx.datetime.toJavaInstant
+import kotlinx.datetime.toKotlinInstant
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.impl.api.Parsers
+import org.jetbrains.kotlinx.dataframe.impl.catchSilent
+import org.jetbrains.kotlinx.dataframe.type
+import org.junit.Test
+import java.util.Locale
+import kotlin.random.Random
+import kotlin.reflect.typeOf
+import kotlin.time.Duration
+import kotlin.time.Duration.Companion.days
+import kotlin.time.Duration.Companion.hours
+import kotlin.time.Duration.Companion.microseconds
+import kotlin.time.Duration.Companion.milliseconds
+import kotlin.time.Duration.Companion.minutes
+import kotlin.time.Duration.Companion.nanoseconds
+import kotlin.time.Duration.Companion.seconds
+import java.time.Duration as JavaDuration
+import java.time.Instant as JavaInstant
+
+class ParseTests {
+    @Test
+    fun parseDate() {
+        val currentLocale = Locale.getDefault()
+        try {
+            Locale.setDefault(Locale.forLanguageTag("en-US"))
+            val date by columnOf("January 1, 2020")
+            val pattern = "MMMM d, yyyy"
+
+            val parsed = date.parse(ParserOptions(dateTimePattern = pattern)).cast<LocalDate>()
+
+            parsed.type() shouldBe typeOf<LocalDate>()
+            with(parsed[0]) {
+                month shouldBe Month.JANUARY
+                dayOfMonth shouldBe 1
+                year shouldBe 2020
+            }
+
+            date.convertToLocalDate(pattern) shouldBe parsed
+            with(date.toDataFrame()) {
+                convert { date }.toLocalDate(pattern)[date] shouldBe parsed
+                parse(ParserOptions(dateTimePattern = pattern))[date] shouldBe parsed
+            }
+
+            DataFrame.parser.addDateTimePattern(pattern)
+
+            date.parse() shouldBe parsed
+            date.convertToLocalDate() shouldBe parsed
+
+            DataFrame.parser.resetToDefault()
+        } finally {
+            Locale.setDefault(currentLocale)
+        }
+    }
+
+    @Test
+    fun parseDateTime() {
+        val currentLocale = Locale.getDefault()
+        try {
+            Locale.setDefault(Locale.forLanguageTag("en-US"))
+            val dateTime by columnOf("3 Jun 2008 13:05:30")
+            val pattern = "d MMM yyyy HH:mm:ss"
+            val locale = Locale.forLanguageTag("en-US")
+
+            val parsed = dateTime.parse(ParserOptions(dateTimePattern = pattern, locale = locale)).cast<LocalDateTime>()
+
+            parsed.type() shouldBe typeOf<LocalDateTime>()
+            with(parsed[0]) {
+                month shouldBe Month.JUNE
+                dayOfMonth shouldBe 3
+                year shouldBe 2008
+                hour shouldBe 13
+                minute shouldBe 5
+                second shouldBe 30
+            }
+
+            dateTime.convertToLocalDateTime(pattern, locale) shouldBe parsed
+            with(dateTime.toDataFrame()) {
+                convert { dateTime }.toLocalDateTime(pattern)[dateTime] shouldBe parsed
+                parse(ParserOptions(dateTimePattern = pattern))[dateTime] shouldBe parsed
+            }
+
+            DataFrame.parser.addDateTimePattern(pattern)
+
+            dateTime.parse(ParserOptions(locale = locale)) shouldBe parsed
+            dateTime.convertToLocalDateTime(pattern, locale) shouldBe parsed
+
+            DataFrame.parser.resetToDefault()
+        } finally {
+            Locale.setDefault(currentLocale)
+        }
+    }
+
+    @Test
+    fun parseTime() {
+        val time by columnOf(" 13-05-30")
+        val pattern = "HH-mm-ss"
+
+        val parsed = time.parse(ParserOptions(dateTimePattern = pattern)).cast<LocalTime>()
+
+        parsed.type() shouldBe typeOf<LocalTime>()
+        with(parsed[0]) {
+            hour shouldBe 13
+            minute shouldBe 5
+            second shouldBe 30
+        }
+        time.convertToLocalTime(pattern) shouldBe parsed
+        with(time.toDataFrame()) {
+            convert { time }.toLocalTime(pattern)[time] shouldBe parsed
+            parse(ParserOptions(dateTimePattern = pattern))[time] shouldBe parsed
+        }
+
+        DataFrame.parser.addDateTimePattern(pattern)
+
+        time.parse() shouldBe parsed
+        time.convertToLocalTime() shouldBe parsed
+
+        DataFrame.parser.resetToDefault()
+    }
+
+    @Test
+    fun `parse date without formatter`() {
+        val time by columnOf(" 2020-01-06", "2020-01-07 ")
+        val df = dataFrameOf(time)
+        val casted = df.convert(time).toLocalDate()
+        casted[time].type() shouldBe typeOf<LocalDate>()
+    }
+
+    @Test
+    fun `parse column group`() {
+        val df = dataFrameOf("a", "b")("1", "2")
+        df
+            .group("a", "b")
+            .into("c")
+            .parse("c")
+            .ungroup("c") shouldBe dataFrameOf("a", "b")(1, 2)
+    }
+
+    @Test
+    fun `parse instant`() {
+        columnOf("2022-01-23T04:29:40Z").parse().type shouldBe typeOf<Instant>()
+        columnOf("2022-01-23T04:29:40+01:00").parse().type shouldBe typeOf<Instant>()
+
+        columnOf("2022-01-23T04:29:40").parse().type shouldBe typeOf<LocalDateTime>()
+    }
+
+    @Test
+    fun `can parse instants`() {
+        val instantParser = Parsers[typeOf<Instant>()]!!.applyOptions(null)
+        val javaInstantParser = Parsers[typeOf<JavaInstant>()]!!.applyOptions(null)
+
+        // from the kotlinx-datetime tests, java instants treat leap seconds etc. like this
+        fun parseInstantLikeJavaDoesOrNull(input: String): Instant? =
+            catchSilent {
+                DateTimeComponents.Formats.ISO_DATE_TIME_OFFSET.parseOrNull(input)?.apply {
+                    when {
+                        hour == 24 && minute == 0 && second == 0 && nanosecond == 0 -> {
+                            setDate(toLocalDate().plus(1, DateTimeUnit.DAY))
+                            hour = 0
+                        }
+
+                        hour == 23 && minute == 59 && second == 60 -> second = 59
+                    }
+                }?.toInstantUsingOffset()
+            }
+
+        fun formatTwoDigits(i: Int) = if (i < 10) "0$i" else "$i"
+
+        for (hour in 23..25) {
+            for (minute in listOf(0..5, 58..62).flatten()) {
+                for (second in listOf(0..5, 58..62).flatten()) {
+                    val input = "2020-03-16T$hour:${formatTwoDigits(minute)}:${formatTwoDigits(second)}Z"
+
+                    val myParserRes = instantParser(input) as Instant?
+                    val myJavaParserRes = javaInstantParser(input) as JavaInstant?
+                    val instantRes = catchSilent { Instant.parse(input) }
+                    val instantLikeJava = parseInstantLikeJavaDoesOrNull(input)
+                    val javaInstantRes = catchSilent { JavaInstant.parse(input) }
+
+                    // our parser has a fallback mechanism built in, like this
+                    myParserRes shouldBe (instantRes ?: javaInstantRes?.toKotlinInstant())
+                    myParserRes shouldBe instantLikeJava
+
+                    myJavaParserRes shouldBe javaInstantRes
+
+                    myParserRes?.toJavaInstant() shouldBe instantLikeJava?.toJavaInstant()
+                    instantLikeJava?.toJavaInstant() shouldBe myJavaParserRes
+                    myJavaParserRes shouldBe javaInstantRes
+                }
+            }
+        }
+    }
+
+    @Test
+    fun `parse duration`() {
+        columnOf("1d 15m", "20h 35m 11s").parse() shouldBe
+            columnOf(1.days + 15.minutes, 20.hours + 35.minutes + 11.seconds)
+    }
+
+    @Test
+    fun `can parse duration isoStrings`() {
+        val durationParser = Parsers[typeOf<Duration>()]!!.applyOptions(null) as (String) -> Duration?
+        val javaDurationParser = Parsers[typeOf<JavaDuration>()]!!.applyOptions(null) as (String) -> JavaDuration?
+
+        fun testSuccess(duration: Duration, vararg isoStrings: String) {
+            isoStrings.first() shouldBe duration.toIsoString()
+            for (isoString in isoStrings) {
+                Duration.parse(isoString) shouldBe duration
+                durationParser(isoString) shouldBe duration
+
+                javaDurationParser(isoString) shouldBe catchSilent { JavaDuration.parse(isoString) }
+            }
+        }
+
+        // zero
+        testSuccess(Duration.ZERO, "PT0S", "P0D", "PT0H", "PT0M", "P0DT0H", "PT0H0M", "PT0H0S")
+
+        // single unit
+        testSuccess(1.days, "PT24H", "P1D", "PT1440M", "PT86400S")
+        testSuccess(1.hours, "PT1H")
+        testSuccess(1.minutes, "PT1M")
+        testSuccess(1.seconds, "PT1S")
+        testSuccess(1.milliseconds, "PT0.001S")
+        testSuccess(1.microseconds, "PT0.000001S")
+        testSuccess(1.nanoseconds, "PT0.000000001S", "PT0.0000000009S")
+        testSuccess(0.9.nanoseconds, "PT0.000000001S")
+
+        // rounded to zero
+        testSuccess(0.1.nanoseconds, "PT0S")
+        testSuccess(Duration.ZERO, "PT0S", "PT0.0000000004S")
+
+        // several units combined
+        testSuccess(1.days + 1.minutes, "PT24H1M")
+        testSuccess(1.days + 1.seconds, "PT24H0M1S")
+        testSuccess(1.days + 1.milliseconds, "PT24H0M0.001S")
+        testSuccess(1.hours + 30.minutes, "PT1H30M")
+        testSuccess(1.hours + 500.milliseconds, "PT1H0M0.500S")
+        testSuccess(2.minutes + 500.milliseconds, "PT2M0.500S")
+        testSuccess(90_500.milliseconds, "PT1M30.500S")
+
+        // with sign
+        testSuccess(-1.days + 15.minutes, "-PT23H45M", "PT-23H-45M", "+PT-24H+15M")
+        testSuccess(-1.days - 15.minutes, "-PT24H15M", "PT-24H-15M", "-PT25H-45M")
+        testSuccess(Duration.ZERO, "PT0S", "P1DT-24H", "+PT-1H+60M", "-PT1M-60S")
+
+        // infinite
+        testSuccess(
+            Duration.INFINITE,
+            "PT9999999999999H",
+            "PT+10000000000000H",
+            "-PT-9999999999999H",
+            "-PT-1234567890123456789012S",
+        )
+        testSuccess(-Duration.INFINITE, "-PT9999999999999H", "-PT10000000000000H", "PT-1234567890123456789012S")
+
+        fun testFailure(isoString: String) {
+            catchSilent { Duration.parse(isoString) } shouldBe durationParser(isoString)
+            catchSilent { JavaDuration.parse(isoString) } shouldBe javaDurationParser(isoString)
+        }
+
+        listOf(
+            "",
+            " ",
+            "P",
+            "PT",
+            "P1DT",
+            "P1",
+            "PT1",
+            "0",
+            "+P",
+            "+",
+            "-",
+            "h",
+            "H",
+            "something",
+            "1m",
+            "1d",
+            "2d 11s",
+            "Infinity",
+            "-Infinity", // successful in kotlin, not in java
+            "P+12+34D",
+            "P12-34D",
+            "PT1234567890-1234567890S",
+            " P1D",
+            "PT1S ",
+            "P3W",
+            "P1Y",
+            "P1M",
+            "P1S",
+            "PT1D",
+            "PT1Y",
+            "PT1S2S",
+            "PT1S2H",
+            "P9999999999999DT-9999999999999H",
+            "PT1.5H",
+            "PT0.5D",
+            "PT.5S",
+            "PT0.25.25S",
+        ).forEach(::testFailure)
+    }
+
+    @Test
+    fun `can parse duration default kotlin strings`() {
+        val durationParser = Parsers[typeOf<Duration>()]!!.applyOptions(null) as (String) -> Duration?
+
+        fun testParsing(string: String, expectedDuration: Duration) {
+            Duration.parse(string) shouldBe expectedDuration
+            durationParser(string) shouldBe expectedDuration
+        }
+
+        fun testSuccess(duration: Duration, vararg expected: String) {
+            val actual = duration.toString()
+            actual shouldBe expected.first()
+
+            if (duration.isPositive()) {
+                if (' ' in actual) {
+                    (-duration).toString() shouldBe "-($actual)"
+                } else {
+                    (-duration).toString() shouldBe "-$actual"
+                }
+            }
+
+            for (string in expected) {
+                testParsing(string, duration)
+                if (duration.isPositive() && duration.isFinite()) {
+                    testParsing("+($string)", duration)
+                    testParsing("-($string)", -duration)
+                    if (' ' !in string) {
+                        testParsing("+$string", duration)
+                        testParsing("-$string", -duration)
+                    }
+                }
+            }
+        }
+
+        testSuccess(101.days, "101d", "2424h")
+        testSuccess(45.3.days, "45d 7h 12m", "45.3d", "45d 7.2h") // 0.3d == 7.2h
+        testSuccess(45.days, "45d")
+
+        testSuccess(40.5.days, "40d 12h", "40.5d", "40d 720m")
+        testSuccess(40.days + 20.minutes, "40d 0h 20m", "40d 20m", "40d 1200s")
+        testSuccess(40.days + 20.seconds, "40d 0h 0m 20s", "40d 20s")
+        testSuccess(40.days + 100.nanoseconds, "40d 0h 0m 0.000000100s", "40d 100ns")
+
+        testSuccess(40.hours + 15.minutes, "1d 16h 15m", "40h 15m")
+        testSuccess(40.hours, "1d 16h", "40h")
+
+        testSuccess(12.5.hours, "12h 30m")
+        testSuccess(12.hours + 15.seconds, "12h 0m 15s")
+        testSuccess(12.hours + 1.nanoseconds, "12h 0m 0.000000001s")
+        testSuccess(30.minutes, "30m")
+        testSuccess(17.5.minutes, "17m 30s")
+
+        testSuccess(16.5.minutes, "16m 30s")
+        testSuccess(1097.1.seconds, "18m 17.1s")
+        testSuccess(90.36.seconds, "1m 30.36s")
+        testSuccess(50.seconds, "50s")
+        testSuccess(1.3.seconds, "1.3s")
+        testSuccess(1.seconds, "1s")
+
+        testSuccess(0.5.seconds, "500ms")
+        testSuccess(40.2.milliseconds, "40.2ms")
+        testSuccess(4.225.milliseconds, "4.225ms")
+        testSuccess(4.24501.milliseconds, "4.245010ms", "4ms 245us 10ns")
+        testSuccess(1.milliseconds, "1ms")
+
+        testSuccess(0.75.milliseconds, "750us")
+        testSuccess(75.35.microseconds, "75.35us")
+        testSuccess(7.25.microseconds, "7.25us")
+        testSuccess(1.035.microseconds, "1.035us")
+        testSuccess(1.005.microseconds, "1.005us")
+        testSuccess(1800.nanoseconds, "1.8us", "1800ns", "0.0000000005h")
+
+        testSuccess(950.5.nanoseconds, "951ns")
+        testSuccess(85.23.nanoseconds, "85ns")
+        testSuccess(8.235.nanoseconds, "8ns")
+        testSuccess(1.nanoseconds, "1ns", "0.9ns", "0.001us", "0.0009us")
+        testSuccess(1.3.nanoseconds, "1ns")
+        testSuccess(0.75.nanoseconds, "1ns")
+        testSuccess(0.7512.nanoseconds, "1ns")
+
+        // equal to zero
+//        testSuccess(0.023.nanoseconds, "0.023ns")
+//        testSuccess(0.0034.nanoseconds, "0.0034ns")
+//        testSuccess(0.0000035.nanoseconds, "0.0000035ns")
+
+        testSuccess(Duration.ZERO, "0s", "0.4ns", "0000.0000ns")
+        testSuccess(365.days * 10000, "3650000d")
+        testSuccess(300.days * 100000, "30000000d")
+        testSuccess(365.days * 100000, "36500000d")
+        testSuccess(((Long.MAX_VALUE / 2) - 1).milliseconds, "53375995583d 15h 36m 27.902s") // max finite value
+
+        // all infinite
+//        val universeAge = Duration.days(365.25) * 13.799e9
+//        val planckTime = Duration.seconds(5.4e-44)
+
+//        testSuccess(universeAge, "5.04e+12d")
+//        testSuccess(planckTime, "5.40e-44s")
+//        testSuccess(Duration.nanoseconds(Double.MAX_VALUE), "2.08e+294d")
+        testSuccess(Duration.INFINITE, "Infinity", "53375995583d 20h", "+Infinity")
+        testSuccess(-Duration.INFINITE, "-Infinity", "-(53375995583d 20h)")
+
+        fun testFailure(isoString: String) {
+            catchSilent { Duration.parse(isoString) } shouldBe durationParser(isoString)
+        }
+
+        listOf(
+            "",
+            " ",
+            "P",
+            "PT",
+            "P1DT",
+            "P1",
+            "PT1",
+            "0",
+            "+P",
+            "+",
+            "-",
+            "h",
+            "H",
+            "something",
+            "1234567890123456789012ns",
+            "Inf",
+            "-Infinity value",
+            "1s ",
+            " 1s",
+            "1d 1m 1h",
+            "1s 2s",
+            "-12m 15s",
+            "-12m -15s",
+            "-()",
+            "-(12m 30s",
+            "+12m 15s",
+            "+12m +15s",
+            "+()",
+            "+(12m 30s",
+            "()",
+            "(12m 30s)",
+            "12.5m 11.5s",
+            ".2s",
+            "0.1553.39m",
+            "P+12+34D",
+            "P12-34D",
+            "PT1234567890-1234567890S",
+            " P1D",
+            "PT1S ",
+            "P1Y",
+            "P1M",
+            "P1S",
+            "PT1D",
+            "PT1Y",
+            "PT1S2S",
+            "PT1S2H",
+            "P9999999999999DT-9999999999999H",
+            "PT1.5H",
+            "PT0.5D",
+            "PT.5S",
+            "PT0.25.25S",
+        ).forEach(::testFailure)
+    }
+
+    @Test
+    fun `Parse normal string column`() {
+        val df = dataFrameOf(List(5_000) { "_$it" }).fill(100) {
+            Random.nextInt().toChar().toString() + Random.nextInt().toChar()
+        }
+
+        df.parse()
+    }
+
+    /**
+     * Asserts that all elements of the iterable are equal to each other
+     */
+    private fun <T> Iterable<T>.shouldAllBeEqual(): Iterable<T> {
+        this should {
+            it.reduce { a, b ->
+                a shouldBe b
+                b
+            }
+        }
+        return this
+    }
+}
diff --git a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/pivot.kt b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/pivot.kt
new file mode 100644
index 000000000..c85d05e79
--- /dev/null
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/pivot.kt
@@ -0,0 +1,189 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import io.kotest.matchers.shouldBe
+import org.jetbrains.kotlinx.dataframe.impl.commonType
+import org.junit.Test
+import kotlin.reflect.typeOf
+
+@Suppress("ktlint:standard:argument-list-wrapping")
+class PivotTests {
+
+    val a by columnOf(0, 1, 1)
+    val b by columnOf("q", "q", "w")
+    val c by columnOf('x', 'y', 'z')
+
+    val df = dataFrameOf(a, b, c)
+
+    @Test
+    fun `simple pivot`() {
+        val pivoted = df.pivot(b, inward = false).groupBy(a).values(c)
+        pivoted.columnNames() shouldBe listOf("a", "q", "w")
+        pivoted.rowsCount() shouldBe 2
+        pivoted["q"].values() shouldBe listOf('x', 'y')
+        pivoted["w"].values() shouldBe listOf(null, 'z')
+    }
+
+    @Test
+    fun `pivot with rename`() {
+        val pivoted = df.pivot(b).groupBy(a).values { c default '?' into "d" and (c into "e") }
+        pivoted.columnNames() shouldBe listOf("a", "b")
+        pivoted.rowsCount() shouldBe 2
+
+        pivoted["b"]["q"]["d"].values() shouldBe listOf('x', 'y')
+        pivoted["b"]["q"]["e"].values() shouldBe listOf('x', 'y')
+        pivoted["b"]["w"]["d"].values() shouldBe listOf('?', 'z')
+        pivoted["b"]["w"]["e"].values() shouldBe listOf(null, 'z')
+    }
+
+    @Test
+    fun `pivot aggregate with default`() {
+        val pivoted = df.pivot(b, inward = false).groupBy(a).aggregate {
+            get(c).first() default '-' into "first"
+            get(c).last() into "last" default '?'
+        }
+        pivoted.columnsCount() shouldBe 3
+        pivoted.rowsCount() shouldBe 2
+        val cols = pivoted.getColumns { allExcept(a).colsAtAnyDepth { !it.isColumnGroup() } }
+        cols.size shouldBe 4
+        cols.forEach {
+            it.type() shouldBe typeOf<Char>()
+        }
+        pivoted["w"]["first"][0] shouldBe '-'
+        pivoted["w"]["last"][0] shouldBe '?'
+    }
+
+    @Test
+    fun `pivot groupBy inward by default`() {
+        val df = dataFrameOf(
+            "a", "b",
+        )(
+            2, "a",
+            4, "b",
+            3, "c",
+        )
+        val pivoted = df.pivot("b").groupBy("a").matches()
+        pivoted.columnNames() shouldBe listOf("a", "b")
+        pivoted.getColumnGroup("b").columnNames() shouldBe listOf("a", "b", "c")
+    }
+
+    @Test
+    fun `pivot values with nulls`() {
+        val df = dataFrameOf("a" to listOf(1, 2, 2, 3), "b" to listOf(1, 1, null, null))
+
+        df.pivot("a").values("b") shouldBe
+            dataFrameOf("1", "2", "3")(1, listOf(1, null), null)[0]
+
+        df.pivot("a").values("b", dropNA = true) shouldBe
+            dataFrameOf("1" to listOf(1), "2" to listOf(1), "3" to listOf<Int?>(null))[0]
+    }
+
+    @Test
+    fun `pivot in aggregate`() {
+        val df = dataFrameOf("a" to listOf(1, 2, 2), "b" to listOf("q", "w", "q"))
+
+        val expected = dataFrameOf("a", "q", "w")(
+            1, 1, 0,
+            2, 1, 1,
+        ).group("q", "w").into("b")
+
+        df.groupBy("a").aggregate {
+            pivot("b").count()
+        } shouldBe expected
+
+        df.groupBy("a").aggregate {
+            pivot("b").count() into "c"
+        } shouldBe expected.rename("b" to "c")
+    }
+
+    @Test
+    fun `pivot two in aggregate`() {
+        val df = dataFrameOf(
+            "a" to listOf(1, 2, 2),
+            "b" to listOf("q", "w", "q"),
+            "c" to listOf("w", "q", "w"),
+        )
+
+        val expected = dataFrameOf(
+            columnOf(1, 2) named "a",
+            columnOf(
+                columnOf(
+                    columnOf(1, 1) named "q",
+                    columnOf(0, 1) named "w",
+                ) named "b",
+                columnOf(
+                    columnOf(1, 1) named "w",
+                    columnOf(0, 1) named "q",
+                ) named "c",
+            ) named "d",
+        )
+
+        df.groupBy("a").aggregate {
+            pivot("b", "c").count() into "d"
+        } shouldBe expected
+    }
+
+    @Test
+    fun `pivot minBy values`() {
+        val df = dataFrameOf("a", "b", "c", "d")(
+            1, 2, 3, 5,
+            1, 0, 2, 4,
+            2, 1, 3, 2,
+            2, 5, 5, 3,
+        )
+        df.pivot("a").minBy("b").values("c", "d", separate = true) shouldBe
+            dataFrameOf("c1", "c2", "d1", "d2")(
+                2, 3, 4, 2,
+            ).move { all() }.into { pathOf(it.name()[0].toString(), it.name()[1].toString()) }[0]
+    }
+
+    @Test
+    fun `pivot groupBy last with`() {
+        val df = dataFrameOf("a", "b", "c")(
+            1, 2, 3,
+            1, 0, 2,
+            2, 1, 3,
+            2, 1, 5,
+        )
+        df.pivot("a", inward = false).groupBy("b").default(-1).last().with { "c"<Int>() } shouldBe
+            dataFrameOf("b", "1", "2")(
+                2, 3, -1,
+                0, 2, -1,
+                1, -1, 5,
+            )
+    }
+
+    @Test
+    fun `pivot then in aggregate`() {
+        val df = dataFrameOf(
+            "category1" to List(12) { it % 3 },
+            "category2" to List(12) { "category2_${it % 2}" },
+            "category3" to List(12) { "category3_${it % 5}" },
+            "value" to List(12) { it },
+        )
+
+        val df1 = df.groupBy("category1").aggregate {
+            pivot { "category2" then "category3" }.count()
+        }
+        df1 shouldBe df.pivot { "category2" then "category3" }.groupBy("category1").count()
+    }
+
+    @Test
+    fun `pivot with default of other type`() {
+        val df = dataFrameOf("firstName", "lastName", "age", "city", "weight", "isHappy")(
+            "Alice", "Cooper", 15, "London", 54, true,
+            "Bob", "Dylan", 45, "Dubai", 87, true,
+            "Charlie", "Daniels", 20, "Moscow", null, false,
+            "Charlie", "Chaplin", 40, "Milan", null, true,
+            "Bob", "Marley", 30, "Tokyo", 68, true,
+            "Alice", "Wolf", 20, null, 55, false,
+            "Charlie", "Byrd", 30, "Moscow", 90, true,
+        ).group("firstName", "lastName").into("name")
+
+        val pivoted = df
+            .pivot("city")
+            .groupBy("name")
+            .default(0)
+            .min()
+        pivoted["city"]["London"]["isHappy"].type() shouldBe listOf(typeOf<Int>(), typeOf<Boolean>()).commonType()
+    }
+}
diff --git a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/remove.kt b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/remove.kt
new file mode 100644
index 000000000..65ee4a159
--- /dev/null
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/remove.kt
@@ -0,0 +1,36 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import io.kotest.matchers.shouldBe
+import org.jetbrains.kotlinx.dataframe.impl.api.removeImpl
+import org.junit.Test
+
+class RemoveTests {
+
+    val df = dataFrameOf("a", "b")(1, 2)
+    val b by column<Int>()
+
+    data class C(val b: Int)
+
+    @Test
+    fun `simple remove`() {
+        val e = df.select("a")
+        df.remove("b") shouldBe e
+        df.remove { b } shouldBe e
+        df.remove(C::b) shouldBe e
+    }
+
+    @Test
+    fun `remove renamed`() {
+        val (_, removed) = df.removeImpl { "a" named "c" }
+        removed[0].data.column!!.name shouldBe "c"
+    }
+
+    @Test
+    fun `remove missing column`() {
+        val d = df.remove { b }
+
+        d.remove("b") shouldBe d
+        d.remove { b } shouldBe d
+        d.remove(C::b) shouldBe d
+    }
+}
diff --git a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/rename.kt b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/rename.kt
new file mode 100644
index 000000000..f28525a44
--- /dev/null
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/rename.kt
@@ -0,0 +1,224 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import io.kotest.assertions.asClue
+import io.kotest.assertions.throwables.shouldNotThrowAny
+import io.kotest.matchers.shouldBe
+import org.jetbrains.kotlinx.dataframe.impl.columns.asAnyFrameColumn
+import org.jetbrains.kotlinx.dataframe.samples.api.age
+import org.junit.Test
+
+@Suppress("ktlint:standard:argument-list-wrapping")
+class RenameTests : ColumnsSelectionDslTests() {
+
+    companion object {
+        val simpleDf = dataFrameOf("a", "b", "c")(
+            1, 2, 3,
+            4, 5, 6,
+        )
+        val groupedDf = simpleDf.group { "a" and "b" }.into("group")
+
+        val doubleGroupedDf = groupedDf.group { "group"["a"] }.into { "group"["aGroup"] }
+    }
+
+    @Test
+    fun `simple rename`() {
+        val renamedDf = dataFrameOf("a_renamed", "b_renamed", "c_renamed")(
+            1, 2, 3,
+            4, 5, 6,
+        )
+
+        simpleDf.rename { all() }.into { it.name + "_renamed" } shouldBe renamedDf
+        simpleDf.rename { all() }.into("a_renamed", "b_renamed", "c_renamed") shouldBe renamedDf
+    }
+
+    @Test
+    fun `partial grouped rename`() {
+        val renamedDf = dataFrameOf("a_renamed", "b", "c")(
+            1, 2, 3,
+            4, 5, 6,
+        ).group { "a_renamed" and "b" }.into("group_renamed")
+
+        groupedDf
+            .rename { "group" and "group"["a"] }
+            .into { it.name + "_renamed" } shouldBe renamedDf
+    }
+
+    @Test
+    fun `grouped rename`() {
+        val renamedDf = dataFrameOf("a_renamed", "b_renamed", "c_renamed")(
+            1, 2, 3,
+            4, 5, 6,
+        ).group { "a_renamed" and "b_renamed" }.into("group_renamed")
+
+        groupedDf
+            .rename { colsAtAnyDepth() }
+            .into { it.name + "_renamed" } shouldBe renamedDf
+    }
+
+    @Test
+    fun `double grouped rename in 3 steps`() {
+        val renamedDf = dataFrameOf("a_renamed", "b_renamed", "c_renamed")(
+            1, 2, 3,
+            4, 5, 6,
+        )
+            .group { "a_renamed" and "b_renamed" }.into("group_renamed")
+            .group { "group_renamed"["a_renamed"] }.into { "group_renamed"["aGroup_renamed"] }
+
+        doubleGroupedDf
+            .rename { colsAtAnyDepth() }
+            .into { it.name + "_renamed" } shouldBe renamedDf
+    }
+
+    interface Person2 {
+        val age2: Int
+    }
+
+    @Test
+    fun `selection dsl`() {
+        val age2 by column<Int>()
+        val dfRenamed = df.rename { age }.into(age2)
+
+        listOf(
+            dfRenamed.select { age2 },
+            df.select { expr { age } named "age2" },
+            df.select { expr { age } into "age2" },
+            df.select { expr { age } named age2 },
+            df.select { expr { age } into age2 },
+            df.select { expr { age } named Person2::age2 },
+            df.select { expr { age } into Person2::age2 },
+            df.select { expr { age } named pathOf("age2") },
+            df.select { expr { age } into pathOf("age2") },
+            df.select { expr { age } named col("age2") },
+            df.select { expr { age } into col("age2") },
+            df.select { age named "age2" },
+            df.select { age into "age2" },
+            df.select { age named age2 },
+            df.select { age into age2 },
+            df.select { age named Person2::age2 },
+            df.select { age into Person2::age2 },
+            df.select { age named pathOf("age2") },
+            df.select { age into pathOf("age2") },
+            df.select { age named col("age2") },
+            df.select { age into col("age2") },
+            df.select { "age" named "age2" },
+            df.select { "age" into "age2" },
+            df.select { "age" named age2 },
+            df.select { "age" into age2 },
+            df.select { "age" named Person2::age2 },
+            df.select { "age" into Person2::age2 },
+            df.select { "age" named pathOf("age2") },
+            df.select { "age" into pathOf("age2") },
+            df.select { "age" named col("age2") },
+            df.select { "age" into col("age2") },
+            df.select { Person::age named "age2" },
+            df.select { Person::age into "age2" },
+            df.select { Person::age named age2 },
+            df.select { Person::age into age2 },
+            df.select { Person::age named Person2::age2 },
+            df.select { Person::age into Person2::age2 },
+            df.select { Person::age named pathOf("age2") },
+            df.select { Person::age into pathOf("age2") },
+            df.select { Person::age named col("age2") },
+            df.select { Person::age into col("age2") },
+            df.select { pathOf("age") named "age2" },
+            df.select { pathOf("age") into "age2" },
+            df.select { pathOf("age") named age2 },
+            df.select { pathOf("age") into age2 },
+            df.select { pathOf("age") named Person2::age2 },
+            df.select { pathOf("age") into Person2::age2 },
+            df.select { pathOf("age") named pathOf("age2") },
+            df.select { pathOf("age") into pathOf("age2") },
+            df.select { pathOf("age") named col("age2") },
+            df.select { pathOf("age") into col("age2") },
+            df.select { col("age") named "age2" },
+            df.select { col("age") into "age2" },
+            df.select { col("age") named age2 },
+            df.select { col("age") into age2 },
+            df.select { col("age") named Person2::age2 },
+            df.select { col("age") into Person2::age2 },
+            df.select { col("age") named pathOf("age2") },
+            df.select { col("age") into pathOf("age2") },
+            df.select { col("age") named col("age2") },
+            df.select { col("age") into col("age2") },
+        ).shouldAllBeEqual()
+    }
+}
+
+class RenameToCamelCaseTests {
+    companion object {
+        val nestedDf = dataFrameOf("test_name")(dataFrameOf("another_name")(1))
+        val nestedColumnGroup = dataFrameOf("test_name")(
+            dataFrameOf("another_name")(1).first(),
+        )
+        val doublyNestedColumnGroup = dataFrameOf("test_name")(
+            dataFrameOf("another_name")(
+                dataFrameOf("third_name")(1).first(),
+            ).first(),
+        )
+        val deeplyNestedDf = kotlin.run {
+            val df = dataFrameOf("another_name")(1)
+            val rowWithDf = dataFrameOf("group_name")(df).first()
+            dataFrameOf("test_name")(rowWithDf)
+        }
+        val deeplyNestedFrameColumn = kotlin.run {
+            val df = dataFrameOf("col_0")(1)
+            val df1 = dataFrameOf("col_1")(df)
+            dataFrameOf("col_2")(df1)
+        }
+    }
+
+    @Test
+    fun `nested df`() {
+        nestedDf.renameToCamelCase() shouldBe dataFrameOf("testName")(dataFrameOf("anotherName")(1))
+    }
+
+    @Test
+    fun `nested row`() {
+        val df = nestedColumnGroup.renameToCamelCase()
+        df.columnNames() shouldBe listOf("testName")
+        df.getColumnGroup("testName").columnNames() shouldBe listOf("anotherName")
+    }
+
+    @Test
+    fun `doubly nested row`() {
+        val doublyNestedColumnGroup = dataFrameOf("test_name")(
+            dataFrameOf("another_name")(
+                dataFrameOf("third_name")(1).first(),
+            ).first(),
+        )
+
+        val df = doublyNestedColumnGroup.renameToCamelCase()
+        df.columnNames() shouldBe listOf("testName")
+        df["testName"].asColumnGroup().columnNames() shouldBe listOf("anotherName")
+        df["testName"]["anotherName"].asColumnGroup().columnNames() shouldBe listOf("thirdName")
+    }
+
+    @Test
+    fun `deeply nested df`() {
+        val df = deeplyNestedDf.renameToCamelCase()
+        df.schema().asClue {
+            df.columnNames() shouldBe listOf("testName")
+            df.getColumnGroup("testName").columnNames() shouldBe listOf("groupName")
+            df["testName"]["groupName"].asAnyFrameColumn()[0].columnNames() shouldBe listOf("anotherName")
+        }
+    }
+
+    @Test
+    fun `deeply nested frame column`() {
+        val df = deeplyNestedFrameColumn.renameToCamelCase()
+        df.schema().asClue {
+            shouldNotThrowAny {
+                df["col2"].asAnyFrameColumn()
+                    .firstOrNull()!!["col1"].asAnyFrameColumn()
+                    .firstOrNull()!!["col0"]
+            }
+        }
+    }
+
+    @Test
+    fun `rename to camelCase`() {
+        val dfWithUpperCaseColumnNames = dataFrameOf("First_Column", "second_column", "ThirdColumn")(1, 2, 3)
+        val df = dfWithUpperCaseColumnNames.renameToCamelCase()
+        df.columnNames() shouldBe listOf("firstColumn", "secondColumn", "thirdColumn")
+    }
+}
diff --git a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/reorder.kt b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/reorder.kt
new file mode 100644
index 000000000..b7627fc9b
--- /dev/null
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/reorder.kt
@@ -0,0 +1,33 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import io.kotest.matchers.shouldBe
+import org.junit.Test
+
+class ReorderTests {
+
+    @Test
+    fun simple() {
+        val df = dataFrameOf("b", "c", "a").fill(1, 0)
+        df.reorder { all() }.byName().columnNames() shouldBe listOf("a", "b", "c")
+        df.reorder { "a" and "c" }.byName().columnNames() shouldBe listOf("b", "a", "c")
+        df.reorder { "a" and "b" }.byName().columnNames() shouldBe listOf("a", "c", "b")
+    }
+
+    @Test
+    fun nested() {
+        val df = dataFrameOf("b", "c", "a")
+            .fill(1, 0)
+            .group("c", "a")
+            .into("a")
+
+        df.reorder { all() }.byName().columnNames() shouldBe listOf("a", "b")
+
+        val sorted1 = df.reorder { "a".allCols() }.byName()
+        sorted1.columnNames() shouldBe listOf("b", "a")
+        sorted1["a"].asColumnGroup().columnNames() shouldBe listOf("a", "c")
+
+        val sorted2 = df.reorder { colsAtAnyDepth() }.byName()
+        sorted2.columnNames() shouldBe listOf("a", "b")
+        sorted2["a"].asColumnGroup().columnNames() shouldBe listOf("a", "c")
+    }
+}
diff --git a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/replace.kt b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/replace.kt
new file mode 100644
index 000000000..5df15bf10
--- /dev/null
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/replace.kt
@@ -0,0 +1,16 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import io.kotest.matchers.shouldBe
+import org.junit.Test
+import kotlin.reflect.typeOf
+
+class ReplaceTests {
+
+    @Test
+    fun `replace named`() {
+        val df = dataFrameOf("a")(1)
+        val conv = df.replace { "a"<Int>() named "b" }.with { it.convertToDouble() }
+        conv.columnNames() shouldBe listOf("b")
+        conv.columnTypes() shouldBe listOf(typeOf<Double>())
+    }
+}
diff --git a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/reverse.kt b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/reverse.kt
new file mode 100644
index 000000000..39f351db9
--- /dev/null
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/reverse.kt
@@ -0,0 +1,27 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import io.kotest.matchers.shouldBe
+import org.junit.Test
+
+class ReverseTests {
+
+    @Test
+    fun dataframe() {
+        val df = dataFrameOf("a", "b")(1, 2, 3, 4)
+        df.reverse() shouldBe dataFrameOf("a", "b")(3, 4, 1, 2)
+    }
+
+    @Test
+    fun column() {
+        val col by columnOf(1, 2, 3)
+        col.reverse() shouldBe col.withValues(listOf(3, 2, 1))
+    }
+
+    @Test
+    fun columnGroup() {
+        val a by columnOf(1, 2)
+        val b by columnOf(3, 4)
+        val col by columnOf(a, b)
+        col.reverse() shouldBe columnOf(a.reverse(), b.reverse()).named("col")
+    }
+}
diff --git a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/select.kt b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/select.kt
new file mode 100644
index 000000000..6ad9012df
--- /dev/null
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/select.kt
@@ -0,0 +1,50 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import org.jetbrains.kotlinx.dataframe.DataRow
+import org.jetbrains.kotlinx.dataframe.samples.api.firstName
+import org.jetbrains.kotlinx.dataframe.samples.api.lastName
+import org.jetbrains.kotlinx.dataframe.samples.api.name
+import org.junit.Test
+
+class SelectTests : ColumnsSelectionDslTests() {
+
+    @Suppress(
+        "CANDIDATE_CHOSEN_USING_OVERLOAD_RESOLUTION_BY_LAMBDA_ANNOTATION",
+        "ktlint:standard:unnecessary-parentheses-before-trailing-lambda",
+    )
+    @Test
+    fun select() {
+        // should not compile:
+//         df.select {
+//             name.select {
+//                 name.firstName
+//             }
+//         }
+
+        listOf(
+            df.select { name.firstName and name.lastName },
+            df.select { name.select { firstName and lastName } },
+            df.select { name { firstName and lastName } },
+            df.select { "name".select { colsOf<String>() } },
+            df.select { "name" { colsOf<String>() } },
+            df.select { colGroup("name").select { colsOf<String>() } },
+            df.select { colGroup<Name>("name").select { colsOf<String>() } },
+            df.select { (colGroup<Name>("name")) { colsOf<String>() } },
+            df.select { colGroup<Name>("name")() { colsOf<String>() } },
+            df.select { "name".select { "firstName" and "lastName" } },
+            df.select { "name" { "firstName" and "lastName" } },
+            df.select { pathOf("name").select { "firstName" and "lastName" } },
+            df.select { pathOf("name")() { "firstName" and "lastName" } },
+            df.select { it["name"].asColumnGroup().select { colsOf<String>() } },
+            df.select { it["name"].asColumnGroup()() { colsOf<String>() } },
+            df.select { name { colsOf<String>() } },
+            df.select { (it["name"].asColumnGroup()) { colsOf<String>() } },
+            df.select { NonDataSchemaPerson::name.select { firstName and lastName } },
+            df.select { NonDataSchemaPerson::name { firstName and lastName } },
+            df.select { "name"<DataRow<Name>>().select { colsOf<String>() } },
+            df.select { "name"<DataRow<Name>>()() { colsOf<String>() } },
+            df.select { colGroup("name").select { colsOf<String>() } },
+            df.select { colGroup("name")() { colsOf<String>() } },
+        ).shouldAllBeEqual()
+    }
+}
diff --git a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/simplify.kt b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/simplify.kt
new file mode 100644
index 000000000..24f72c3fc
--- /dev/null
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/simplify.kt
@@ -0,0 +1,51 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import io.kotest.matchers.shouldBe
+import org.jetbrains.kotlinx.dataframe.samples.api.age
+import org.jetbrains.kotlinx.dataframe.samples.api.firstName
+import org.jetbrains.kotlinx.dataframe.samples.api.lastName
+import org.jetbrains.kotlinx.dataframe.samples.api.name
+import org.jetbrains.kotlinx.dataframe.samples.api.secondName
+import org.junit.Test
+
+class SimplifyTests : ColumnsSelectionDslTests() {
+
+    @Test
+    fun simplify() {
+        df.select {
+            cols(name.firstName, name.lastName, age).simplify()
+        } shouldBe df.select {
+            cols(name.firstName, name.lastName, age)
+        }
+
+        df.select {
+            cols(name.firstName, name.lastName, name.lastName, age, age, name).simplify()
+        } shouldBe df.select {
+            cols(name, age)
+        }
+
+        df.select {
+            colsAtAnyDepth().simplify()
+        } shouldBe df.select {
+            all()
+        }
+
+        df.select {
+            cols(name.firstName).simplify()
+        } shouldBe df.select {
+            cols(name.firstName)
+        }
+
+        dfGroup.select {
+            (name and name.firstName.secondName and name.lastName).simplify()
+        } shouldBe dfGroup.select {
+            name
+        }
+
+        dfGroup.select {
+            (name.firstName.secondName and name.lastName).simplify()
+        } shouldBe dfGroup.select {
+            name.firstName.secondName and name.lastName
+        }
+    }
+}
diff --git a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/single.kt b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/single.kt
new file mode 100644
index 000000000..9fbb91e15
--- /dev/null
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/single.kt
@@ -0,0 +1,49 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import io.kotest.assertions.throwables.shouldThrow
+import org.jetbrains.kotlinx.dataframe.samples.api.firstName
+import org.jetbrains.kotlinx.dataframe.samples.api.name
+import org.junit.Test
+
+class SingleTests : ColumnsSelectionDslTests() {
+
+    @Test
+    fun `ColumnsSelectionDsl single`() {
+        shouldThrow<IllegalArgumentException> {
+            df.select { "age".singleCol() }
+        }
+        shouldThrow<IllegalArgumentException> {
+            df.select { columnGroup(Person::age).singleCol() }
+        }
+        shouldThrow<IllegalArgumentException> {
+            df.select { Person::age.singleCol() }
+        }
+        shouldThrow<NoSuchElementException> {
+            df.select { single { false } }
+        }
+        shouldThrow<IllegalArgumentException> {
+            df.select { single { true } }
+        }
+
+        val singleDf = df.select { take(1) }
+
+        listOf(
+            df.select { name },
+            singleDf.select { name },
+            singleDf.select { single() },
+            singleDf.select { all().single() },
+            df.select { single { it.name().startsWith("n") } },
+        ).shouldAllBeEqual()
+
+        listOf(
+            df.select { name.firstName },
+            df.select { name.colsOf<String>().single { col -> col.any { it == "Alice" } } },
+            df.select { name.singleCol { col -> col.any { it == "Alice" } } },
+            df.select { "name".singleCol { col -> col.any { it == "Alice" } } },
+            df.select { Person::name.singleCol { col -> col.any { it == "Alice" } } },
+            df.select { NonDataSchemaPerson::name.singleCol { col -> col.any { it == "Alice" } } },
+            df.select { pathOf("name").singleCol { col -> col.any { it == "Alice" } } },
+            df.select { it["name"].asColumnGroup().singleCol { col -> col.any { it == "Alice" } } },
+        ).shouldAllBeEqual()
+    }
+}
diff --git a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/sort.kt b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/sort.kt
new file mode 100644
index 000000000..5972ea7c4
--- /dev/null
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/sort.kt
@@ -0,0 +1,100 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import io.kotest.assertions.throwables.shouldThrowMessage
+import io.kotest.matchers.shouldBe
+import org.jetbrains.kotlinx.dataframe.DataColumn
+import org.jetbrains.kotlinx.dataframe.io.readDataFrame
+import org.jetbrains.kotlinx.dataframe.nrow
+import org.jetbrains.kotlinx.dataframe.testResource
+import org.jetbrains.kotlinx.dataframe.testSets.DsSalaries
+import org.jetbrains.kotlinx.dataframe.testSets.companyLocation
+import org.jetbrains.kotlinx.dataframe.testSets.companySize
+import org.jetbrains.kotlinx.dataframe.testSets.salaryInUsd
+import org.junit.Test
+
+class SortDataColumn {
+
+    @Test
+    fun `value column sort with`() {
+        val col = DataColumn.createValueColumn("", listOf(1, 6, 8, 4, 2, 9))
+        val sortedCol = col.sort()
+        val descSortedCol = col.sortDesc()
+
+        col.sortWith { a, b -> a - b } shouldBe sortedCol
+        col.sortWith { a, b -> b - a } shouldBe descSortedCol
+
+        col.sortWith(Int::compareTo) shouldBe sortedCol
+        col.sortWith(compareBy { it }) shouldBe sortedCol
+    }
+
+    @Test
+    fun `frame column sort with`() {
+        val col = DataColumn.createFrameColumn(
+            "",
+            listOf(
+                dataFrameOf("a")(1, 2),
+                dataFrameOf("a")(1),
+                dataFrameOf("a")(1, 2, 3),
+            ),
+        )
+        val sortedCol = DataColumn.createFrameColumn(
+            "",
+            listOf(
+                dataFrameOf("a")(1),
+                dataFrameOf("a")(1, 2),
+                dataFrameOf("a")(1, 2, 3),
+            ),
+        )
+
+        col.sortWith { df1, df2 -> df1.nrow - df2.nrow } shouldBe sortedCol
+        col.sortWith(compareBy { it.nrow }) shouldBe sortedCol
+    }
+
+    @Test
+    fun `column group sort with`() {
+        val a by column<Int>()
+        val b by column<String>()
+
+        val col = DataColumn.createColumnGroup(
+            "",
+            dataFrameOf(
+                columnOf(1, 3, 2) named a,
+                columnOf("hello", "world", "!") named b,
+            ),
+        )
+
+        val sortedCol = DataColumn.createColumnGroup(
+            "",
+            dataFrameOf(
+                columnOf(1, 2, 3) named a,
+                columnOf("hello", "!", "world") named b,
+            ),
+        )
+
+        col.sortWith { df1, df2 -> df1[a] - df2[a] } shouldBe sortedCol
+        col.sortWith(compareBy { it[a] }) shouldBe sortedCol
+    }
+
+    @Test
+    fun `sort by nested column`() {
+        val df = testResource("ds_salaries.csv").readDataFrame().cast<DsSalaries>()
+        val aggregate = df.pivot(false) { companySize }.groupBy { companyLocation }.aggregate {
+            maxOf { salaryInUsd } into "salary"
+            maxBy { salaryInUsd } into "extra"
+        }
+        aggregate.sortBy(pathOf("L", "salary"))[0][pathOf("L", "salary")] shouldBe null
+        aggregate.sortByDesc(pathOf("L", "salary"))[0][pathOf("L", "salary")] shouldBe 600_000
+    }
+
+    @Test
+    fun `sort by invalid nested column`() {
+        val df = testResource("ds_salaries.csv").readDataFrame().cast<DsSalaries>()
+        val aggregate = df.pivot(false) { companySize }.groupBy { companyLocation }.aggregate {
+            maxOf { salaryInUsd } into "salary"
+            maxBy { salaryInUsd } into "extra"
+        }
+        shouldThrowMessage("Can not use ColumnGroup as sort column") {
+            aggregate.sortBy(pathOf("L", "extra"))
+        }
+    }
+}
diff --git a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/sortGroupedDataframe.kt b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/sortGroupedDataframe.kt
new file mode 100644
index 000000000..3e6a8bb56
--- /dev/null
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/sortGroupedDataframe.kt
@@ -0,0 +1,74 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import io.kotest.matchers.shouldBe
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.alsoDebug
+import org.jetbrains.kotlinx.dataframe.io.read
+import org.junit.Test
+
+class SortGroupedDataframeTests {
+
+    @Test
+    fun `Sorted grouped iris dataset`() {
+        val irisData = DataFrame.read("src/test/resources/irisDataset.csv")
+        irisData.alsoDebug()
+
+        irisData.groupBy("variety").let {
+            it.sortBy("petal.length").toString() shouldBe
+                it.sortBy { it["petal.length"] }.toString()
+        }
+    }
+
+    enum class State {
+        Idle,
+        Productive,
+        Maintenance,
+    }
+
+    @Test
+    fun test4() {
+        class Event(val toolId: String, val state: State, val timestamp: Long)
+
+        val tool1 = "tool_1"
+        val tool2 = "tool_2"
+        val tool3 = "tool_3"
+
+        val events = listOf(
+            Event(tool1, State.Idle, 0),
+            Event(tool1, State.Productive, 5),
+            Event(tool2, State.Idle, 0),
+            Event(tool2, State.Maintenance, 10),
+            Event(tool2, State.Idle, 20),
+            Event(tool3, State.Idle, 0),
+            Event(tool3, State.Productive, 25),
+        ).toDataFrame()
+
+        val lastTimestamp = events.maxOf { getValue<Long>("timestamp") }
+        val groupBy = events
+            .groupBy("toolId")
+            .sortBy("timestamp")
+            .add("stateDuration") {
+                (next()?.getValue("timestamp") ?: lastTimestamp) - getValue<Long>("timestamp")
+            }
+
+        groupBy.toDataFrame().alsoDebug()
+        groupBy.schema().print()
+        groupBy.keys.print()
+        groupBy.keys[0].print()
+
+        val df1 = groupBy.updateGroups {
+            val missingValues = State.values().asList().toDataFrame {
+                "state" from { it }
+            }
+
+            val df = it
+                .fullJoin(missingValues, "state")
+                .fillNulls("stateDuration")
+                .with { 100L }
+
+            df.groupBy("state").sumFor("stateDuration")
+        }
+
+        df1.toDataFrame().alsoDebug().isNotEmpty() shouldBe true
+    }
+}
diff --git a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/split.kt b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/split.kt
new file mode 100644
index 000000000..7cdb7ef10
--- /dev/null
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/split.kt
@@ -0,0 +1,176 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import io.kotest.matchers.shouldBe
+import org.jetbrains.kotlinx.dataframe.AnyFrame
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.hasNulls
+import org.jetbrains.kotlinx.dataframe.impl.DataRowImpl
+import org.jetbrains.kotlinx.dataframe.type
+import org.junit.Test
+import kotlin.reflect.typeOf
+
+@Suppress("ktlint:standard:argument-list-wrapping")
+class SplitTests {
+
+    val stringPairDf = dataFrameOf("first", "second")("22-65", "22-66")
+    val listPairDf = dataFrameOf("first", "second")(listOf("22", "65"), listOf("22", "66"))
+
+    @Test
+    fun `split with default`() {
+        val recentDelays = listOf(
+            listOf(23, 47),
+            listOf(),
+            listOf(24, 43, 87),
+            listOf(13),
+            listOf(67, 32),
+        ).toColumn("RecentDelays")
+        val df = dataFrameOf(recentDelays)
+        val split = df.split(recentDelays).default(0).into { "delay$it" }
+        split.columns().forEach {
+            it.hasNulls() shouldBe false
+        }
+        split.values().count { it == 0 } shouldBe 7
+    }
+
+    @Test
+    fun `split with regex`() {
+        val title by columnOf(
+            "Toy Story (1995)",
+            "Jumanji (1995)",
+            "Grumpier Old Men (1995)",
+            "Waiting to Exhale (1995)",
+        )
+
+        val regex = """(.*) \((\d{4})\)""".toRegex()
+        val split = title.toDataFrame()
+            .split { title }.match(regex).into("title", "year")
+            .parse()
+        split.schema().print()
+        split["title"].hasNulls shouldBe false
+        split["year"].type shouldBe typeOf<Int>()
+    }
+
+    @Test
+    fun `split into columns`() {
+        val df = dataFrameOf("a", "b", "c")(
+            1, 2, 3,
+            1, 4, 5,
+            2, 3, 4,
+            3, 6, 7,
+        )
+        val res = df
+            .groupBy("a").updateGroups { it.remove("a") }.into("g")
+            .update("g").at(1).with { DataFrame.empty() }
+            .update("g").at(2).withNull()
+            .split { "g"<AnyFrame>() }.intoColumns()
+            .ungroup("g")
+        res shouldBe dataFrameOf("a", "b", "c")(
+            1, listOf(2, 4), listOf(3, 5),
+            2, emptyList<Int>(), emptyList<Int>(),
+            3, emptyList<Int>(), emptyList<Int>(),
+        )
+    }
+
+    @Test
+    fun `split string by delimiter inward`() {
+        val res = stringPairDf.split("first", "second").by("-").inward("left", "right")
+
+        res shouldBe dataFrameOf(
+            columnOf(columnOf("22") named "left", columnOf("65") named "right") named "first",
+            columnOf(columnOf("22") named "left", columnOf("66") named "right") named "second",
+        )
+    }
+
+    @Test
+    fun `split string by delimiter into columns with suffixes`() {
+        val res = stringPairDf.split("first", "second").by("-").into("left", "right")
+
+        res shouldBe dataFrameOf(
+            columnOf("22") named "left",
+            columnOf("65") named "right",
+            columnOf("22") named "left1",
+            columnOf("66") named "right1",
+        )
+    }
+
+    @Test
+    fun `split list inward with autogenerated names`() {
+        val res = listPairDf.split { "first"<List<String>>() and "second"<List<String>>() }.inward()
+
+        res shouldBe dataFrameOf(
+            columnOf(columnOf("22") named "split1", columnOf("65") named "split2") named "first",
+            columnOf(columnOf("22") named "split1", columnOf("66") named "split2") named "second",
+        )
+    }
+
+    @Test
+    fun `split list into with autogenerated names`() {
+        val res = listPairDf.split { "first"<List<String>>() and "second"<List<String>>() }.into()
+
+        res shouldBe dataFrameOf(
+            columnOf("22") named "split1",
+            columnOf("65") named "split2",
+            columnOf("22") named "split3",
+            columnOf("66") named "split4",
+        )
+    }
+
+    @Test
+    fun `sequence of splits with autogenerated names`() {
+        var res = listPairDf.split { "first"<List<String>>() }.into()
+        res = res.split { "second"<List<String>>() }.into()
+
+        res shouldBe dataFrameOf(
+            columnOf("22") named "split1",
+            columnOf("65") named "split2",
+            columnOf("22") named "split3",
+            columnOf("66") named "split4",
+        )
+    }
+
+    @Test
+    fun `split column group inward`() {
+        val df = stringPairDf.group("first", "second").into("group")
+
+        // Note: this operation replaces original columns in group so there is no name conflict
+        val res = df
+            .split { "group"<DataRowImpl<*>>() }
+            .by { it -> listOf(it[1], it[0]) } // swap columns
+            .inward("first", "second") // no name conflict
+
+        res shouldBe dataFrameOf(
+            columnOf(columnOf("22-66") named "first", columnOf("22-65") named "second") named "group",
+        )
+    }
+
+    @Test
+    fun `split column group into hierarchy with correct names`() {
+        val df = dataFrameOf(
+            columnOf(
+                columnOf("a") named "first",
+                columnOf(
+                    columnOf("b") named "first",
+                    columnOf("c") named "second",
+                ) named "nestedGroup",
+            ) named "topLevelGroup",
+            columnOf("d") named "first",
+        )
+
+        val topLevelGroup by columnGroup()
+        val nestedGroup by topLevelGroup.columnGroup()
+
+        val res = df
+            .split { nestedGroup }
+            .by { it -> listOf(it[0], it[1]) }
+            .into("first", "second") // name conflict
+
+        res shouldBe dataFrameOf(
+            columnOf(
+                columnOf("a") named "first",
+                columnOf("b") named "first1",
+                columnOf("c") named "second",
+            ) named "topLevelGroup",
+            columnOf("d") named "first",
+        )
+    }
+}
diff --git a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/take.kt b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/take.kt
new file mode 100644
index 000000000..a28e4270b
--- /dev/null
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/take.kt
@@ -0,0 +1,47 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import org.jetbrains.kotlinx.dataframe.samples.api.firstName
+import org.jetbrains.kotlinx.dataframe.samples.api.lastName
+import org.jetbrains.kotlinx.dataframe.samples.api.name
+import org.junit.Test
+
+class TakeTests : ColumnsSelectionDslTests() {
+
+    @Test
+    fun `take and takeLast`() {
+        listOf(
+            df.select { name.firstName },
+            df.select { name.takeCols(1) },
+            df.select { "name".takeCols(1) },
+            df.select { Person::name.takeCols(1) },
+            df.select { pathOf("name").takeCols(1) },
+        ).shouldAllBeEqual()
+
+        listOf(
+            df.select { name.lastName },
+            df.select { name.takeLastCols(1) },
+            df.select { "name".takeLastCols(1) },
+            df.select { Person::name.takeLastCols(1) },
+            df.select { pathOf("name").takeLastCols(1) },
+        ).shouldAllBeEqual()
+    }
+
+    @Test
+    fun `takeWhile and takeLastWhile`() {
+        listOf(
+            df.select { name.firstName },
+            df.select { name.takeColsWhile { it.name == "firstName" } },
+            df.select { "name".takeColsWhile { it.name == "firstName" } },
+            df.select { Person::name.takeColsWhile { it.name == "firstName" } },
+            df.select { pathOf("name").takeColsWhile { it.name == "firstName" } },
+        ).shouldAllBeEqual()
+
+        listOf(
+            df.select { name.lastName },
+            df.select { name.takeLastColsWhile { it.name == "lastName" } },
+            df.select { "name".takeLastColsWhile { it.name == "lastName" } },
+            df.select { Person::name.takeLastColsWhile { it.name == "lastName" } },
+            df.select { pathOf("name").takeLastColsWhile { it.name == "lastName" } },
+        ).shouldAllBeEqual()
+    }
+}
diff --git a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/toDataFrame.kt b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/toDataFrame.kt
new file mode 100644
index 000000000..7a68f5d3f
--- /dev/null
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/toDataFrame.kt
@@ -0,0 +1,463 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import io.kotest.assertions.throwables.shouldNotThrowAny
+import io.kotest.matchers.shouldBe
+import org.jetbrains.kotlinx.dataframe.DataColumn
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.DataRow
+import org.jetbrains.kotlinx.dataframe.annotations.DataSchema
+import org.jetbrains.kotlinx.dataframe.columns.ColumnKind
+import org.jetbrains.kotlinx.dataframe.kind
+import org.jetbrains.kotlinx.dataframe.type
+import org.junit.Ignore
+import org.junit.Test
+import java.io.File
+import kotlin.reflect.KProperty
+import kotlin.reflect.typeOf
+
+class CreateDataFrameTests {
+
+    @Test
+    fun `visibility test`() {
+        class Data {
+            private val a = 1
+            protected val b = 2
+            internal val c = 3
+            public val d = 4
+        }
+
+        listOf(Data()).toDataFrame() shouldBe dataFrameOf("d")(4)
+    }
+
+    @Test
+    fun `exception test`() {
+        class Data {
+            val a: Int get() = error("Error")
+            val b = 1
+        }
+
+        val df = listOf(Data()).toDataFrame()
+        df.columnsCount() shouldBe 2
+        df.rowsCount() shouldBe 1
+        df.columnTypes() shouldBe listOf(typeOf<IllegalStateException>(), typeOf<Int>())
+        (df["a"][0] is IllegalStateException) shouldBe true
+        df["b"][0] shouldBe 1
+    }
+
+    @Test
+    fun `create frame column`() {
+        val df = dataFrameOf("a")(1)
+        val res = listOf(1, 2).toDataFrame {
+            "a" from { it }
+            "b" from { df }
+            "c" from { df[0] }
+            "d" from { if (it == 1) it else null }
+            "e" from { if (true) it else null }
+        }
+        res["a"].kind shouldBe ColumnKind.Value
+        res["a"].type() shouldBe typeOf<Int>()
+        res["b"].kind shouldBe ColumnKind.Frame
+        res["c"].kind shouldBe ColumnKind.Group
+        res["d"].type() shouldBe typeOf<Int?>()
+        res["e"].type() shouldBe typeOf<Int>()
+    }
+
+    @Test
+    fun `create column with infer type`() {
+        val data: List<Any> = listOf(1, 2, 3)
+        val res = data.toDataFrame {
+            "e" from inferType { it }
+            expr(infer = Infer.Type) { it } into "d"
+        }
+
+        res["e"].type() shouldBe typeOf<Int>()
+        res["e"].kind() shouldBe ColumnKind.Value
+
+        res["d"].type() shouldBe typeOf<Int>()
+        res["d"].kind() shouldBe ColumnKind.Value
+    }
+
+    @Test
+    fun `preserve fields order`() {
+        class B(val x: Int, val c: String, d: Double) {
+            val b: Int = x
+            val a: Double = d
+        }
+
+        listOf(B(1, "a", 2.0)).toDataFrame().columnNames() shouldBe listOf("x", "c", "a", "b")
+    }
+
+    @DataSchema
+    data class A(val v: Int)
+
+    @DataSchema
+    data class B(
+        val str: String,
+        val frame: DataFrame<A>,
+        val row: DataRow<A>,
+        val list: List<A>,
+        val a: A,
+    )
+
+    @Test
+    fun `preserve properties test`() {
+        val d1 = listOf(A(2), A(3)).toDataFrame()
+        val d2 = listOf(A(4), A(5)).toDataFrame()
+
+        val data = listOf(
+            B("q", d1, d1[0], emptyList(), A(7)),
+            B("w", d2, d2[1], listOf(A(6)), A(8)),
+        )
+
+        val df = data.toDataFrame()
+
+        df.frame.kind shouldBe ColumnKind.Frame
+        df.row.kind() shouldBe ColumnKind.Group
+        df.list.kind shouldBe ColumnKind.Frame
+        df.a.kind() shouldBe ColumnKind.Group
+
+        df.str[1] shouldBe "w"
+        df.frame[0].v[1] shouldBe 3
+        df.row[1].v shouldBe 5
+        df.list[1].v[0] shouldBe 6
+        df.a[0].v shouldBe 7
+
+        val df2 = data.toDataFrame {
+            preserve(B::row)
+            properties { preserve(DataFrame::class) }
+        }
+        df2.frame.kind shouldBe ColumnKind.Value
+        df2.frame.type shouldBe typeOf<DataFrame<A>>()
+        df2["row"].kind shouldBe ColumnKind.Value
+        df2["row"].type shouldBe typeOf<DataRow<A>>()
+        df2.list.kind shouldBe ColumnKind.Frame
+        df2.a.kind() shouldBe ColumnKind.Group
+    }
+
+    enum class DummyEnum { A }
+
+    @Test
+    fun `don't convert value types`() {
+        data class Entry(
+            val a: Int,
+            val b: String,
+            val c: Boolean,
+            val e: DummyEnum,
+        )
+
+        val df = listOf(Entry(1, "s", true, DummyEnum.A)).toDataFrame(maxDepth = 100)
+        df.columns().forEach {
+            it.kind shouldBe ColumnKind.Value
+        }
+    }
+
+    @Test
+    fun `convert type with no properties`() {
+        class Child
+
+        class Entry(val a: Int, val child: Child)
+
+        val df = listOf(Entry(1, Child())).toDataFrame(maxDepth = 100)
+        df.rowsCount() shouldBe 1
+
+        val childCol = df[Entry::child]
+        childCol.kind() shouldBe ColumnKind.Group
+        childCol.asColumnGroup().columnsCount() shouldBe 0
+    }
+
+    @Test
+    fun `convert child schemas`() {
+        class Child2(val s: String)
+
+        @DataSchema
+        class Child1(val child: Child2)
+
+        @DataSchema
+        class Entry(val a: Int, val child: Child1)
+
+        val df = listOf(Entry(1, Child1(Child2("s")))).toDataFrame()
+        df.rowsCount() shouldBe 1
+
+        val child1 = df[Entry::child]
+        child1.kind shouldBe ColumnKind.Group
+
+        val child2 = child1.asColumnGroup()[Child1::child]
+        child2.kind shouldBe ColumnKind.Value
+    }
+
+    @Test
+    fun inferredTypeForPropertyWithGenericIterableType() {
+        class Container<E>(val data: Set<E>)
+
+        val element = Container(setOf(1))
+        val value = listOf(element).toDataFrame(maxDepth = 10)
+
+        value["data"].type() shouldBe typeOf<List<Int>>()
+    }
+
+    @Test
+    fun inferredNullableTypeForPropertyWithGenericIterableType() {
+        class Container<E>(val data: List<E>)
+
+        val element = Container(listOf(1, null))
+        val value = listOf(element).toDataFrame(maxDepth = 10)
+
+        value["data"].type() shouldBe typeOf<List<Int?>>()
+    }
+
+    @Suppress("unused")
+    @Test
+    fun treatErasedGenericAsAny() {
+        class IncompatibleVersionErrorData<T>(val expected: T, val actual: T)
+
+        class DeserializedContainerSource(val incompatibility: IncompatibleVersionErrorData<*>)
+
+        val functions = listOf(DeserializedContainerSource(IncompatibleVersionErrorData(1, 2)))
+
+        val df = functions.toDataFrame(maxDepth = 2)
+
+        val col = df.getColumnGroup(DeserializedContainerSource::incompatibility)
+        col[IncompatibleVersionErrorData<*>::actual].type() shouldBe typeOf<Any>()
+        col[IncompatibleVersionErrorData<*>::expected].type() shouldBe typeOf<Any>()
+    }
+
+    interface Named {
+        val name: String get() = "default impl"
+    }
+
+    class Data(override val name: String) : Named
+
+    @Test
+    fun simpleInheritance() {
+        val name = "temp"
+        val df = listOf(Data(name)).toDataFrame(maxDepth = 1)
+
+        df["name"][0] shouldBe name
+    }
+
+    @Test
+    fun builtInTypes() {
+        val string = listOf("aaa", "aa", null)
+        string.toDataFrame() shouldBe dataFrameOf("value")(*string.toTypedArray())
+
+        val int = listOf(1, 2, 3)
+        int.toDataFrame() shouldBe dataFrameOf("value")(*int.toTypedArray())
+
+        val doubles = listOf(1.0, 2.0, 3.0)
+        doubles.toDataFrame() shouldBe dataFrameOf("value")(*doubles.toTypedArray())
+
+        val floats = listOf(1.0f, 2.0f, 3.0f)
+        floats.toDataFrame() shouldBe dataFrameOf("value")(*floats.toTypedArray())
+    }
+
+    @Ignore
+    @Test
+    fun generateBuiltInsOverrides() {
+        listOf(
+            "Byte",
+            "Short",
+            "Int",
+            "Long",
+            "String",
+            "Char",
+            "Boolean",
+            "UByte",
+            "UShort",
+            "UInt",
+            "ULong",
+        ).forEach { type ->
+            val typeParameter = type.first()
+            val func =
+                """
+                @JvmName("toDataFrame$type")
+                public inline fun <reified $typeParameter : $type?> Iterable<$typeParameter>.toDataFrame(): DataFrame<ValueProperty<$typeParameter>> = toDataFrame {
+                    ValueProperty<$typeParameter>::value from { it }
+                }.cast()
+                """.trimIndent()
+            println(func)
+            println()
+        }
+    }
+
+    // nullable field here - no generated unwrapping code
+    @JvmInline
+    internal value class Speed(val kmh: Number?)
+
+    internal class PathSegment(val id: String, val speedLimit: Speed? = null)
+
+    @Test
+    fun valueClassNullableField() {
+        val segments = listOf(PathSegment("foo", Speed(2.3)), PathSegment("bar"))
+
+        val df = segments.toDataFrame()
+        df["speedLimit"].values() shouldBe listOf(Speed(2.3), null)
+    }
+
+    @Test
+    fun valueClassNullableField1() {
+        val segments = listOf(PathSegment("foo", Speed(2.3)), PathSegment("bar", Speed(null)))
+
+        val df = segments.toDataFrame()
+        df["speedLimit"].values() shouldBe listOf(Speed(2.3), Speed(null))
+    }
+
+    @JvmInline
+    internal value class Speed1(val kmh: Number)
+
+    internal class PathSegment1(val id: String, val speedLimit: Speed1? = null)
+
+    @Test
+    fun valueClass() {
+        val segments = listOf(PathSegment1("foo", Speed1(2.3)), PathSegment1("bar"))
+
+        val df = segments.toDataFrame()
+        df["speedLimit"].values() shouldBe listOf(Speed1(2.3), null)
+    }
+
+    @Test
+    fun testKPropertyGet() {
+        val segment = PathSegment("bar")
+        val result = PathSegment::speedLimit.call(segment)
+        result shouldBe null
+    }
+
+    fun call(kProperty0: KProperty<*>, obj: Any) = kProperty0.call(obj)
+
+    @Test
+    fun testKPropertyCallLibrary() {
+        val segment = PathSegment1("bar")
+        val result = call(PathSegment1::speedLimit, segment)
+        // Sudden result! I cannot create this value, so toString.
+        // In the test above you can see decompiled code that "fixes" this strange wrapping
+        result.toString() shouldBe "Speed1(kmh=null)"
+    }
+
+    private class PrivateClass(val a: Int)
+
+    @Test
+    fun `convert private class with public members`() {
+        listOf(PrivateClass(1)).toDataFrame() shouldBe dataFrameOf("a")(1)
+    }
+
+    class KotlinPojo {
+
+        private var a: Int = 0
+        private var b: String = ""
+
+        constructor(b: String, a: Int) {
+            this.a = a
+            this.b = b
+        }
+
+        fun getA(): Int = a
+
+        fun setA(a: Int) {
+            this.a = a
+        }
+
+        fun getB(): String = b
+
+        fun setB(b: String) {
+            this.b = b
+        }
+
+        override fun equals(other: Any?): Boolean {
+            if (this === other) return true
+            if (other !is KotlinPojo) return false
+
+            if (a != other.a) return false
+            if (b != other.b) return false
+
+            return true
+        }
+
+        override fun hashCode(): Int {
+            var result = a
+            result = 31 * result + b.hashCode()
+            return result
+        }
+
+        override fun toString(): String = "FakePojo(a=$a, b='$b')"
+    }
+
+    @Test
+    fun `convert POJO to DF`() {
+        // even though the names b, a, follow the constructor order
+        listOf(KotlinPojo("bb", 1)).toDataFrame() shouldBe dataFrameOf("b", "a")("bb", 1)
+
+        // cannot read java constructor parameter names with reflection, so sort lexicographically
+        listOf(JavaPojo(2.0, null, "bb", 1)).toDataFrame() shouldBe
+            dataFrameOf(
+                DataColumn.createValueColumn("a", listOf(1), typeOf<Int>()),
+                DataColumn.createValueColumn("b", listOf("bb"), typeOf<String>()),
+                DataColumn.createValueColumn("c", listOf(null), typeOf<Int?>()),
+                DataColumn.createValueColumn("d", listOf(2.0), typeOf<Number>()),
+            )
+
+        listOf(KotlinPojo("bb", 1)).toDataFrame { properties(KotlinPojo::getA) } shouldBe
+            dataFrameOf("a")(1)
+        listOf(KotlinPojo("bb", 1)).toDataFrame { properties(KotlinPojo::getB) } shouldBe
+            dataFrameOf("b")("bb")
+
+        listOf(JavaPojo(2.0, 3, "bb", 1)).toDataFrame {
+            properties(JavaPojo::getA)
+        } shouldBe dataFrameOf("a")(1)
+
+        listOf(JavaPojo(2.0, 3, "bb", 1)).toDataFrame {
+            properties(JavaPojo::getB)
+        } shouldBe dataFrameOf("b")("bb")
+    }
+
+    data class Arrays(val a: IntArray, val b: Array<Int>, val c: Array<Int?>)
+
+    @Test
+    fun `arrays in to DF`() {
+        val df = listOf(
+            Arrays(intArrayOf(1, 2), arrayOf(3, 4), arrayOf(5, null)),
+        ).toDataFrame(maxDepth = Int.MAX_VALUE)
+
+        df.schema() shouldBe dataFrameOf(
+            DataColumn.createValueColumn("a", listOf(intArrayOf(1, 2)), typeOf<IntArray>()),
+            DataColumn.createValueColumn("b", listOf(arrayOf(3, 4)), typeOf<Array<Int>>()),
+            DataColumn.createValueColumn("c", listOf(arrayOf(5, null)), typeOf<Array<Int?>>()),
+        ).schema()
+    }
+
+    @DataSchema
+    data class Person(
+        val firstName: String,
+        val lastName: String,
+        val age: Int,
+        val city: String?,
+    ) : DataRowSchema
+
+    @DataSchema
+    data class Group(val id: String, val participants: List<Person>) : DataRowSchema
+
+    @Test
+    fun `deeply convert data schema and list of data schema`() {
+        val participants1 = listOf(
+            Person("Alice", "Cooper", 15, "London"),
+            Person("Bob", "Dylan", 45, "Dubai"),
+        )
+        val participants2 = listOf(
+            Person("Charlie", "Daniels", 20, "Moscow"),
+            Person("Charlie", "Chaplin", 40, "Milan"),
+        )
+        val df = dataFrameOf(
+            Group("1", participants1),
+            Group("2", participants2),
+        )
+        shouldNotThrowAny {
+            df.participants[0].firstName
+            df.participants[0].city
+        }
+    }
+
+    @Test
+    fun toDataFrameColumn() {
+        val files = listOf(File("data.csv"))
+        val df = files.toDataFrame(columnName = "files")
+        df["files"][0] shouldBe File("data.csv")
+    }
+}
diff --git a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/toList.kt b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/toList.kt
new file mode 100644
index 000000000..7feb89ab6
--- /dev/null
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/toList.kt
@@ -0,0 +1,27 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import io.kotest.matchers.shouldBe
+import org.junit.Test
+
+class DataClassesTests {
+
+    @Test
+    fun convertDataClasses() {
+        data class Record(val sex: String, val grade: Int, val count: Int)
+
+        data class PivotedRecord(val grade: Int, val male: Int, val female: Int)
+
+        listOf(
+            Record("male", 5, 10),
+            Record("male", 6, 15),
+            Record("female", 5, 20),
+            Record("female", 6, 15),
+        ).toDataFrame()
+            .pivot(Record::sex, inward = false).groupBy(Record::grade).values(Record::count)
+            .toListOf<PivotedRecord>() shouldBe
+            listOf(
+                PivotedRecord(5, 10, 20),
+                PivotedRecord(6, 15, 15),
+            )
+    }
+}
diff --git a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/update.kt b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/update.kt
new file mode 100644
index 000000000..dfc179957
--- /dev/null
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/update.kt
@@ -0,0 +1,82 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import io.kotest.matchers.shouldBe
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.annotations.DataSchema
+import org.jetbrains.kotlinx.dataframe.size
+import org.junit.Test
+
+class UpdateTests {
+
+    @Test
+    fun `update empty dataframe with missing column`() {
+        val df = DataFrame.Empty
+        val col by column<Int>()
+        df.update { col }.with { 2 } shouldBe df
+    }
+
+    @DataSchema
+    interface DataPart {
+        val a: Int
+        val b: String
+    }
+
+    @DataSchema
+    data class Data(override val a: Int, override val b: String, val c: Boolean) : DataPart
+
+    @Test
+    fun `update asFrame`() {
+        val df = listOf(
+            Data(1, "a", true),
+            Data(2, "b", false),
+        ).toDataFrame()
+
+        val group by columnGroup<DataPart>() named "Some Group"
+        val groupedDf = df.group { a and b }.into { group }
+
+        val res = groupedDf
+            .update { group }
+            .where { !c }
+            .asFrame {
+                // size should still be full df size
+                size.nrow shouldBe 2
+
+                // this will only apply to rows where `.where { !c }` holds
+                update { a }.with { 0 }
+            }
+
+        val (first, second) = res.get { group }.map { it.a }.toList()
+        first shouldBe 1
+        second shouldBe 0
+
+        res.get { group }.name() shouldBe "Some Group"
+    }
+
+    @DataSchema
+    interface SchemaA {
+        val i: Int?
+    }
+
+    @DataSchema
+    interface SchemaB {
+        val i: Int
+    }
+
+    @Test
+    fun `fillNulls update`() {
+        val df = dataFrameOf("i")(1, null)
+
+        df.fillNulls(SchemaA::i).with { 42 }
+
+        df.fillNulls(SchemaB::i).with { 42 }
+    }
+
+    @Test
+    fun `fillNA update`() {
+        val df = dataFrameOf("i")(1, null)
+
+        df.fillNA(SchemaA::i).with { 42 }
+
+        df.fillNA(SchemaB::i).with { 42 }
+    }
+}
diff --git a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/valueCol.kt b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/valueCol.kt
new file mode 100644
index 000000000..57cf2711b
--- /dev/null
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/valueCol.kt
@@ -0,0 +1,111 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import io.kotest.assertions.throwables.shouldThrow
+import org.jetbrains.kotlinx.dataframe.samples.api.age
+import org.jetbrains.kotlinx.dataframe.samples.api.firstName
+import org.jetbrains.kotlinx.dataframe.samples.api.name
+import org.junit.Test
+
+class ValueColTests : ColumnsSelectionDslTests() {
+
+    @Test
+    fun `valueCol exceptions`() {
+        shouldThrow<IllegalArgumentException> {
+            df.select { valueCol("name") }
+        }
+        shouldThrow<IllegalStateException> {
+            df.select { valueCol("nonExisting") }
+        }
+        shouldThrow<IllegalStateException> {
+            df.select { name.valueCol("nonExisting") }
+        }
+        shouldThrow<IllegalStateException> {
+            df.select { "age".valueCol("test") }
+        }
+        shouldThrow<IndexOutOfBoundsException> {
+            df.select { valueCol(100) }
+        }
+    }
+
+    @Test
+    fun `valueCol at top-level`() {
+        val ageAccessor = valueColumn<Int>("age")
+        listOf(
+            df.select { age },
+            df.select { valueCol(ageAccessor) },
+            df.select { valueCol("age") },
+            df.select { valueCol<Int>("age") },
+            df.select { valueCol(pathOf("age")) },
+            df.select { valueCol<Int>(pathOf("age")) },
+            df.select { valueCol(Person::age) },
+            df.select { all().valueCol(1) },
+            df.select { valueCol(1) },
+            df.select { valueCol<Int>(1) },
+        ).shouldAllBeEqual()
+    }
+
+    @Test
+    fun `valueCol at lower level`() {
+        val firstNameAccessor = valueColumn<String>("firstName")
+        listOf(
+            df.select { name.firstName },
+            // reference
+            df.select { name.valueCol(firstNameAccessor) },
+            df.select { colGroup("name").valueCol(firstNameAccessor) },
+            df.select { "name".valueCol(firstNameAccessor) },
+            df.select { NonDataSchemaPerson::name.valueCol(firstNameAccessor) },
+            df.select { Person::name.valueCol(firstNameAccessor) },
+            df.select { pathOf("name").valueCol(firstNameAccessor) },
+            // name
+            df.select { name.valueCol("firstName") },
+            df.select { name.valueCol<String>("firstName") },
+            df.select { colGroup("name").valueCol("firstName") },
+            df.select { colGroup("name").valueCol<String>("firstName") },
+            df.select { "name".valueCol("firstName") },
+            df.select { "name".valueCol<String>("firstName") },
+            df.select { NonDataSchemaPerson::name.valueCol("firstName") },
+            df.select { NonDataSchemaPerson::name.valueCol<String>("firstName") },
+            df.select { Person::name.valueCol("firstName") },
+            df.select { Person::name.valueCol<String>("firstName") },
+            df.select { pathOf("name").valueCol("firstName") },
+            df.select { pathOf("name").valueCol<String>("firstName") },
+            // path
+            df.select { name.valueCol(pathOf("firstName")) },
+            df.select { name.valueCol<String>(pathOf("firstName")) },
+            df.select { colGroup("name").valueCol(pathOf("firstName")) },
+            df.select { colGroup("name").valueCol<String>(pathOf("firstName")) },
+            df.select { "name".valueCol(pathOf("firstName")) },
+            df.select { "name".valueCol<String>(pathOf("firstName")) },
+            df.select { NonDataSchemaPerson::name.valueCol(pathOf("firstName")) },
+            df.select { NonDataSchemaPerson::name.valueCol<String>(pathOf("firstName")) },
+            df.select { Person::name.valueCol(pathOf("firstName")) },
+            df.select { Person::name.valueCol<String>(pathOf("firstName")) },
+            df.select { pathOf("name").valueCol(pathOf("firstName")) },
+            df.select { pathOf("name").valueCol<String>(pathOf("firstName")) },
+            df.select { valueCol("name"["firstName"]) },
+            df.select { valueCol<String>("name"["firstName"]) },
+            df.select { asSingleColumn().valueCol("name"["firstName"]) },
+            df.select { asSingleColumn().valueCol<String>("name"["firstName"]) },
+            // property
+            df.select { name.valueCol(Name::firstName) },
+            df.select { colGroup("name").valueCol(Name::firstName) },
+            df.select { "name".valueCol(Name::firstName) },
+            df.select { NonDataSchemaPerson::name.valueCol(Name::firstName) },
+            df.select { Person::name.valueCol(Name::firstName) },
+            df.select { pathOf("name").valueCol(Name::firstName) },
+            // index
+            df.select { name.valueCol(0) },
+            df.select { name.valueCol<String>(0) },
+            df.select { colGroup("name").valueCol(0) },
+            df.select { colGroup("name").valueCol<String>(0) },
+            df.select { "name".valueCol(0) },
+            df.select { "name".valueCol<String>(0) },
+            df.select { NonDataSchemaPerson::name.valueCol(0) },
+            df.select { NonDataSchemaPerson::name.valueCol<String>(0) },
+            df.select { Person::name.valueCol(0) },
+            df.select { Person::name.valueCol<String>(0) },
+            df.select { pathOf("name").valueCol(0) },
+            df.select { pathOf("name").valueCol<String>(0) },
+        ).shouldAllBeEqual()
+    }
+}
diff --git a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/valueCols.kt b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/valueCols.kt
new file mode 100644
index 000000000..9731954b3
--- /dev/null
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/valueCols.kt
@@ -0,0 +1,57 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import io.kotest.assertions.throwables.shouldThrow
+import org.jetbrains.kotlinx.dataframe.samples.api.age
+import org.jetbrains.kotlinx.dataframe.samples.api.city
+import org.jetbrains.kotlinx.dataframe.samples.api.firstName
+import org.jetbrains.kotlinx.dataframe.samples.api.isHappy
+import org.jetbrains.kotlinx.dataframe.samples.api.lastName
+import org.jetbrains.kotlinx.dataframe.samples.api.name
+import org.jetbrains.kotlinx.dataframe.samples.api.weight
+import org.junit.Test
+
+class ValueColsTests : ColumnsSelectionDslTests() {
+
+    @Test
+    fun `valueCols exceptions`() {
+        shouldThrow<IllegalArgumentException> {
+            df.select { "age".valueCols() }
+        }
+    }
+
+    @Test
+    fun `valueCols at top-level`() {
+        listOf(
+            df.select { cols(age, city, weight, isHappy) },
+            df.select { all().valueCols() },
+            df.select { valueCols() },
+        ).shouldAllBeEqual()
+
+        listOf(
+            df.select { age },
+            df.select { age }.select { all() },
+            df.select { age }.select { valueCols() },
+            df.select { age }.select { valueCols().all() },
+            df.select { age }.select { all().valueCols() },
+        ).shouldAllBeEqual()
+
+        listOf(
+            df.select { cols(age, weight) },
+            df.select { valueCols { "e" in it.name() } },
+            df.select { all().valueCols { "e" in it.name() } },
+        ).shouldAllBeEqual()
+    }
+
+    @Test
+    fun `valueCols at lower level`() {
+        listOf(
+            df.select { name.firstName and name.lastName },
+            df.select { name.valueCols { "Name" in it.name() } },
+            df.select { name.colsOf<String>().valueCols { "Name" in it.name() } },
+            df.select { "name".valueCols { "Name" in it.name() } },
+            df.select { Person::name.valueCols { "Name" in it.name() } },
+            df.select { pathOf("name").valueCols { "Name" in it.name() } },
+            df.select { it["name"].asColumnGroup().valueCols { "Name" in it.name() } },
+        ).shouldAllBeEqual()
+    }
+}
diff --git a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/withoutNulls.kt b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/withoutNulls.kt
new file mode 100644
index 000000000..1bb31322f
--- /dev/null
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/withoutNulls.kt
@@ -0,0 +1,30 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import org.jetbrains.kotlinx.dataframe.samples.api.age
+import org.jetbrains.kotlinx.dataframe.samples.api.firstName
+import org.jetbrains.kotlinx.dataframe.samples.api.isHappy
+import org.jetbrains.kotlinx.dataframe.samples.api.name
+import org.junit.Test
+
+class WithoutNullsTests : ColumnsSelectionDslTests() {
+
+    @Test
+    fun `top level`() {
+        listOf(
+            df.select { name and age and isHappy },
+            df.select { withoutNulls() },
+            df.select { all().withoutNulls() },
+        ).shouldAllBeEqual()
+    }
+
+    @Test
+    fun `lower level`() {
+        listOf(
+            dfGroup.select { name.firstName.firstName },
+            dfGroup.select { name.firstName.colsWithoutNulls() },
+            dfGroup.select { "name"["firstName"].colsWithoutNulls() },
+            dfGroup.select { name { "firstName".colsWithoutNulls() } },
+            dfGroup.select { name { Name2::firstName.colsWithoutNulls() } },
+        ).shouldAllBeEqual()
+    }
+}
diff --git a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/codeGen/CodeGenerationTests.kt b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/codeGen/CodeGenerationTests.kt
new file mode 100644
index 000000000..af5090311
--- /dev/null
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/codeGen/CodeGenerationTests.kt
@@ -0,0 +1,376 @@
+package org.jetbrains.kotlinx.dataframe.codeGen
+
+import io.kotest.matchers.shouldBe
+import org.jetbrains.dataframe.impl.codeGen.CodeGenerator
+import org.jetbrains.dataframe.impl.codeGen.InterfaceGenerationMode
+import org.jetbrains.dataframe.impl.codeGen.ReplCodeGenerator
+import org.jetbrains.dataframe.impl.codeGen.generate
+import org.jetbrains.kotlinx.dataframe.AnyRow
+import org.jetbrains.kotlinx.dataframe.ColumnsContainer
+import org.jetbrains.kotlinx.dataframe.DataColumn
+import org.jetbrains.kotlinx.dataframe.DataRow
+import org.jetbrains.kotlinx.dataframe.api.dataFrameOf
+import org.jetbrains.kotlinx.dataframe.api.dropNulls
+import org.jetbrains.kotlinx.dataframe.api.generateDataClasses
+import org.jetbrains.kotlinx.dataframe.api.groupBy
+import org.jetbrains.kotlinx.dataframe.api.move
+import org.jetbrains.kotlinx.dataframe.api.schema
+import org.jetbrains.kotlinx.dataframe.api.toCodeString
+import org.jetbrains.kotlinx.dataframe.api.toDataFrame
+import org.jetbrains.kotlinx.dataframe.api.under
+import org.jetbrains.kotlinx.dataframe.columns.ColumnGroup
+import org.jetbrains.kotlinx.dataframe.impl.codeGen.ReplCodeGeneratorImpl
+import org.jetbrains.kotlinx.dataframe.testSets.person.BaseTest
+import org.jetbrains.kotlinx.dataframe.testSets.person.Person
+import org.junit.Test
+
+class CodeGenerationTests : BaseTest() {
+
+    val personClassName = Person::class.qualifiedName!!
+
+    val personShortName = Person::class.simpleName!!
+
+    val dfName = (ColumnsContainer::class).simpleName!!
+    val dfRowName = (DataRow::class).simpleName!!
+    val dataCol = (DataColumn::class).simpleName!!
+    val dataRow = (DataRow::class).simpleName!!
+    val colGroup = (ColumnGroup::class).simpleName!!
+    val stringName = String::class.simpleName!!
+    val intName = Int::class.simpleName!!
+
+    fun expectedProperties(fullTypeName: String, shortTypeName: String, addNullable: Boolean = false) =
+        buildString {
+            appendLine(
+                """val $dfName<$fullTypeName>.age: $dataCol<$intName> @JvmName("${shortTypeName}_age") get() = this["age"] as $dataCol<$intName>""",
+            )
+            appendLine(
+                """val $dfRowName<$fullTypeName>.age: $intName @JvmName("${shortTypeName}_age") get() = this["age"] as $intName""",
+            )
+            if (addNullable) {
+                appendLine(
+                    """val $dfName<$fullTypeName?>.age: $dataCol<$intName?> @JvmName("Nullable${shortTypeName}_age") get() = this["age"] as $dataCol<$intName?>""",
+                )
+                appendLine(
+                    """val $dfRowName<$fullTypeName?>.age: $intName? @JvmName("Nullable${shortTypeName}_age") get() = this["age"] as $intName?""",
+                )
+            }
+            appendLine(
+                """val $dfName<$fullTypeName>.city: $dataCol<$stringName?> @JvmName("${shortTypeName}_city") get() = this["city"] as $dataCol<$stringName?>""",
+            )
+            appendLine(
+                """val $dfRowName<$fullTypeName>.city: $stringName? @JvmName("${shortTypeName}_city") get() = this["city"] as $stringName?""",
+            )
+            if (addNullable) {
+                appendLine(
+                    """val $dfName<$fullTypeName?>.city: $dataCol<$stringName?> @JvmName("Nullable${shortTypeName}_city") get() = this["city"] as $dataCol<$stringName?>""",
+                )
+                appendLine(
+                    """val $dfRowName<$fullTypeName?>.city: $stringName? @JvmName("Nullable${shortTypeName}_city") get() = this["city"] as $stringName?""",
+                )
+            }
+            appendLine(
+                """val $dfName<$fullTypeName>.name: $dataCol<$stringName> @JvmName("${shortTypeName}_name") get() = this["name"] as $dataCol<$stringName>""",
+            )
+            appendLine(
+                """val $dfRowName<$fullTypeName>.name: $stringName @JvmName("${shortTypeName}_name") get() = this["name"] as $stringName""",
+            )
+            if (addNullable) {
+                appendLine(
+                    """val $dfName<$fullTypeName?>.name: $dataCol<$stringName?> @JvmName("Nullable${shortTypeName}_name") get() = this["name"] as $dataCol<$stringName?>""",
+                )
+                appendLine(
+                    """val $dfRowName<$fullTypeName?>.name: $stringName? @JvmName("Nullable${shortTypeName}_name") get() = this["name"] as $stringName?""",
+                )
+            }
+            appendLine(
+                """val $dfName<$fullTypeName>.weight: $dataCol<$intName?> @JvmName("${shortTypeName}_weight") get() = this["weight"] as $dataCol<$intName?>""",
+            )
+            append(
+                """val $dfRowName<$fullTypeName>.weight: $intName? @JvmName("${shortTypeName}_weight") get() = this["weight"] as $intName?""",
+            )
+            if (addNullable) {
+                appendLine("")
+                appendLine(
+                    """val $dfName<$fullTypeName?>.weight: $dataCol<$intName?> @JvmName("Nullable${shortTypeName}_weight") get() = this["weight"] as $dataCol<$intName?>""",
+                )
+                append(
+                    """val $dfRowName<$fullTypeName?>.weight: $intName? @JvmName("Nullable${shortTypeName}_weight") get() = this["weight"] as $intName?""",
+                )
+            }
+        }
+
+    @Test
+    fun `generate marker interface`() {
+        val codeGen = ReplCodeGenerator.create()
+        val generated = codeGen.process(df, ::df)
+        val typeName = ReplCodeGeneratorImpl.markerInterfacePrefix
+        val expectedDeclaration =
+            """
+            @DataSchema
+            interface $typeName { }
+            
+            """.trimIndent() + "\n" + expectedProperties(typeName, typeName)
+
+        val expectedConverter = "it.cast<$typeName>()"
+
+        generated.declarations shouldBe expectedDeclaration
+        generated.converter("it") shouldBe expectedConverter
+
+        val rowGenerated = codeGen.process(df[0], ::typedRow)
+        rowGenerated.hasDeclarations shouldBe true
+        rowGenerated.hasConverter shouldBe true
+    }
+
+    val row: AnyRow? = null
+
+    val typedRow: DataRow<Person> = typed[0]
+
+    @Test
+    fun `generate marker interface for row`() {
+        val property = ::row
+        val generated = ReplCodeGenerator.create().process(df[0], property)
+        val typeName = ReplCodeGeneratorImpl.markerInterfacePrefix
+        val expectedDeclaration =
+            """
+            @DataSchema
+            interface $typeName { }
+            
+            """.trimIndent() + "\n" + expectedProperties(typeName, typeName)
+
+        val expectedConverter = "it.cast<$typeName>()"
+
+        generated.declarations shouldBe expectedDeclaration
+        generated.converter("it") shouldBe expectedConverter
+    }
+
+    @Test
+    fun `generate marker interface for nested data frame`() {
+        val property = ::df
+        val grouped = df.move { name and city }.under("nameAndCity")
+        val generated = ReplCodeGenerator.create().process(grouped, property)
+        val type1 = ReplCodeGeneratorImpl.markerInterfacePrefix + "1"
+        val type2 = ReplCodeGeneratorImpl.markerInterfacePrefix
+        val declaration1 =
+            """
+            @DataSchema(isOpen = false)
+            interface $type1 { }
+            
+            val $dfName<$type1>.city: $dataCol<$stringName?> @JvmName("${type1}_city") get() = this["city"] as $dataCol<$stringName?>
+            val $dfRowName<$type1>.city: $stringName? @JvmName("${type1}_city") get() = this["city"] as $stringName?
+            val $dfName<$type1>.name: $dataCol<$stringName> @JvmName("${type1}_name") get() = this["name"] as $dataCol<$stringName>
+            val $dfRowName<$type1>.name: $stringName @JvmName("${type1}_name") get() = this["name"] as $stringName
+            
+            """.trimIndent()
+
+        val declaration2 =
+            """
+            @DataSchema
+            interface $type2 { }
+            
+            val $dfName<$type2>.age: $dataCol<$intName> @JvmName("${type2}_age") get() = this["age"] as $dataCol<$intName>
+            val $dfRowName<$type2>.age: $intName @JvmName("${type2}_age") get() = this["age"] as $intName
+            val $dfName<$type2>.nameAndCity: $colGroup<$type1> @JvmName("${type2}_nameAndCity") get() = this["nameAndCity"] as $colGroup<$type1>
+            val $dfRowName<$type2>.nameAndCity: $dataRow<$type1> @JvmName("${type2}_nameAndCity") get() = this["nameAndCity"] as $dataRow<$type1>
+            val $dfName<$type2>.weight: $dataCol<$intName?> @JvmName("${type2}_weight") get() = this["weight"] as $dataCol<$intName?>
+            val $dfRowName<$type2>.weight: $intName? @JvmName("${type2}_weight") get() = this["weight"] as $intName?
+            """.trimIndent()
+
+        val expectedConverter = "it.cast<$type2>()"
+
+        generated.declarations shouldBe declaration1 + "\n" + declaration2
+        generated.converter("it") shouldBe expectedConverter
+    }
+
+    @Test
+    fun `generate extension properties`() {
+        val personClass = (Person::class).qualifiedName!!
+        val expected =
+            """
+            @DataSchema
+            interface $personClass { }
+            """.trimIndent() + "\n" + expectedProperties(personClassName, personShortName, addNullable = true)
+
+        val code = CodeGenerator
+            .create(useFqNames = false)
+            .generate<Person>(InterfaceGenerationMode.NoFields, extensionProperties = true)
+            .declarations
+        code shouldBe expected
+    }
+
+    @Test
+    fun `frame to markers`() {
+        val f = SchemaProcessor.create("Temp")
+        val marker = f.process(df.schema(), true)
+        marker.isOpen shouldBe true
+        f.generatedMarkers shouldBe listOf(marker)
+    }
+
+    @Test
+    fun `generate derived interface`() {
+        val codeGen = CodeGenerator.create()
+        val schema = df.dropNulls().schema()
+        val code = codeGen.generate(
+            schema = schema,
+            name = "ValidPerson",
+            fields = true,
+            extensionProperties = true,
+            isOpen = true,
+            visibility = MarkerVisibility.IMPLICIT_PUBLIC,
+            knownMarkers = listOf(MarkersExtractor.get<Person>()),
+        ).code.declarations
+        val packageName = "org.jetbrains.kotlinx.dataframe"
+        val expected =
+            """
+            @DataSchema
+            interface ValidPerson : $personClassName {
+                override val city: kotlin.String
+                override val weight: kotlin.Int
+            }
+            
+            val $packageName.ColumnsContainer<ValidPerson>.city: $packageName.DataColumn<kotlin.String> @JvmName("ValidPerson_city") get() = this["city"] as $packageName.DataColumn<kotlin.String>
+            val $packageName.DataRow<ValidPerson>.city: kotlin.String @JvmName("ValidPerson_city") get() = this["city"] as kotlin.String
+            val $packageName.ColumnsContainer<ValidPerson>.weight: $packageName.DataColumn<kotlin.Int> @JvmName("ValidPerson_weight") get() = this["weight"] as $packageName.DataColumn<kotlin.Int>
+            val $packageName.DataRow<ValidPerson>.weight: kotlin.Int @JvmName("ValidPerson_weight") get() = this["weight"] as kotlin.Int
+            """.trimIndent()
+        code shouldBe expected
+    }
+
+    @Test
+    fun `empty interface with properties`() {
+        val codeGen = CodeGenerator.create(useFqNames = false)
+        val code = codeGen.generate(df.schema(), "Person", false, true, true).code.declarations
+        val expected =
+            """
+            @DataSchema
+            interface Person { }
+            
+            """.trimIndent() + "\n" + expectedProperties("Person", "Person")
+        code shouldBe expected
+    }
+
+    @Test
+    fun `interface with fields`() {
+        val repl = CodeGenerator.create()
+        val code = repl.generate(typed.schema(), "DataType", true, false, false).code.declarations
+        code shouldBe
+            """
+            @DataSchema(isOpen = false)
+            interface DataType {
+                val age: kotlin.Int
+                val city: kotlin.String?
+                val name: kotlin.String
+                val weight: kotlin.Int?
+            }
+            """.trimIndent()
+    }
+
+    @Test
+    fun `declaration with internal visibility`() {
+        val repl = CodeGenerator.create()
+        val code =
+            repl.generate(typed.schema(), "DataType", true, true, false, MarkerVisibility.INTERNAL).code.declarations
+        val packageName = "org.jetbrains.kotlinx.dataframe"
+        code shouldBe
+            """
+            @DataSchema(isOpen = false)
+            internal interface DataType {
+                val age: kotlin.Int
+                val city: kotlin.String?
+                val name: kotlin.String
+                val weight: kotlin.Int?
+            }
+            
+            internal val $packageName.ColumnsContainer<DataType>.age: $packageName.DataColumn<kotlin.Int> @JvmName("DataType_age") get() = this["age"] as $packageName.DataColumn<kotlin.Int>
+            internal val $packageName.DataRow<DataType>.age: kotlin.Int @JvmName("DataType_age") get() = this["age"] as kotlin.Int
+            internal val $packageName.ColumnsContainer<DataType>.city: $packageName.DataColumn<kotlin.String?> @JvmName("DataType_city") get() = this["city"] as $packageName.DataColumn<kotlin.String?>
+            internal val $packageName.DataRow<DataType>.city: kotlin.String? @JvmName("DataType_city") get() = this["city"] as kotlin.String?
+            internal val $packageName.ColumnsContainer<DataType>.name: $packageName.DataColumn<kotlin.String> @JvmName("DataType_name") get() = this["name"] as $packageName.DataColumn<kotlin.String>
+            internal val $packageName.DataRow<DataType>.name: kotlin.String @JvmName("DataType_name") get() = this["name"] as kotlin.String
+            internal val $packageName.ColumnsContainer<DataType>.weight: $packageName.DataColumn<kotlin.Int?> @JvmName("DataType_weight") get() = this["weight"] as $packageName.DataColumn<kotlin.Int?>
+            internal val $packageName.DataRow<DataType>.weight: kotlin.Int? @JvmName("DataType_weight") get() = this["weight"] as kotlin.Int?
+            """.trimIndent()
+    }
+
+    @Test
+    fun `declaration with explicit public visibility`() {
+        val repl = CodeGenerator.create()
+        val code = repl.generate(
+            typed.schema(),
+            "DataType",
+            true,
+            true,
+            false,
+            MarkerVisibility.EXPLICIT_PUBLIC,
+        ).code.declarations
+        val packageName = "org.jetbrains.kotlinx.dataframe"
+        code shouldBe
+            """
+            @DataSchema(isOpen = false)
+            public interface DataType {
+                public val age: kotlin.Int
+                public val city: kotlin.String?
+                public val name: kotlin.String
+                public val weight: kotlin.Int?
+            }
+            
+            public val $packageName.ColumnsContainer<DataType>.age: $packageName.DataColumn<kotlin.Int> @JvmName("DataType_age") get() = this["age"] as $packageName.DataColumn<kotlin.Int>
+            public val $packageName.DataRow<DataType>.age: kotlin.Int @JvmName("DataType_age") get() = this["age"] as kotlin.Int
+            public val $packageName.ColumnsContainer<DataType>.city: $packageName.DataColumn<kotlin.String?> @JvmName("DataType_city") get() = this["city"] as $packageName.DataColumn<kotlin.String?>
+            public val $packageName.DataRow<DataType>.city: kotlin.String? @JvmName("DataType_city") get() = this["city"] as kotlin.String?
+            public val $packageName.ColumnsContainer<DataType>.name: $packageName.DataColumn<kotlin.String> @JvmName("DataType_name") get() = this["name"] as $packageName.DataColumn<kotlin.String>
+            public val $packageName.DataRow<DataType>.name: kotlin.String @JvmName("DataType_name") get() = this["name"] as kotlin.String
+            public val $packageName.ColumnsContainer<DataType>.weight: $packageName.DataColumn<kotlin.Int?> @JvmName("DataType_weight") get() = this["weight"] as $packageName.DataColumn<kotlin.Int?>
+            public val $packageName.DataRow<DataType>.weight: kotlin.Int? @JvmName("DataType_weight") get() = this["weight"] as kotlin.Int?
+            """.trimIndent()
+    }
+
+    @Test
+    fun `column starts with number`() {
+        val df = dataFrameOf("1a", "-b", "?c")(1, 2, 3)
+        val repl = CodeGenerator.create()
+        val declarations = repl.generate(df.schema(), "DataType", false, true, false).code.declarations
+        df.columnNames().forEach {
+            val matches = "`$it`".toRegex().findAll(declarations).toList()
+            matches.size shouldBe 2
+        }
+    }
+
+    @Test
+    fun `check method generateDataClasses`() {
+        val code = typed.groupBy { name }.toDataFrame().generateDataClasses()
+
+        code shouldBe
+            """
+            @DataSchema
+            data class Person1(
+                val age: Int,
+                val city: String?,
+                val name: String,
+                val weight: Int?
+            )
+
+            @DataSchema
+            data class Person(
+                val group: List<Person1>,
+                val name: String
+            )
+            """.trimIndent().toCodeString()
+    }
+
+    @Test
+    fun `check name normalization for generated data classes`() {
+        dataFrameOf("my_name")(1).generateDataClasses() shouldBe
+            """
+            @DataSchema
+            data class DataEntry(
+                @ColumnName("my_name")
+                val myName: Int
+            )
+            """.trimIndent().toCodeString()
+    }
+
+    @Test
+    fun patterns() {
+        """^[\d]""".toRegex().matches("3fds")
+    }
+}
diff --git a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/codeGen/MatchSchemeTests.kt b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/codeGen/MatchSchemeTests.kt
new file mode 100644
index 000000000..b1ad4013b
--- /dev/null
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/codeGen/MatchSchemeTests.kt
@@ -0,0 +1,102 @@
+package org.jetbrains.kotlinx.dataframe.codeGen
+
+import io.kotest.matchers.shouldBe
+import org.jetbrains.dataframe.impl.codeGen.ReplCodeGenerator
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.DataRow
+import org.jetbrains.kotlinx.dataframe.annotations.DataSchema
+import org.jetbrains.kotlinx.dataframe.api.add
+import org.jetbrains.kotlinx.dataframe.api.cast
+import org.jetbrains.kotlinx.dataframe.api.generateCode
+import org.jetbrains.kotlinx.dataframe.io.readJsonStr
+import org.junit.Test
+
+class MatchSchemeTests {
+
+    @DataSchema(isOpen = false)
+    interface Snippet {
+        val position: Int
+        val info: String
+    }
+
+    @DataSchema(isOpen = false)
+    interface Item {
+        val kind: String
+        val id: String
+        val snippet: DataRow<Snippet>
+    }
+
+    @DataSchema(isOpen = false)
+    interface PageInfo {
+        val totalResults: Int
+        val resultsPerPage: Int
+        val snippets: DataFrame<Snippet>
+    }
+
+    @DataSchema
+    interface DataRecord {
+        val kind: String
+        val items: DataFrame<Item>
+        val pageInfo: DataRow<PageInfo>
+    }
+
+    val json =
+        """
+        {
+            "kind": "qq",
+            "pageInfo": {
+                "totalResults": 2,
+                "resultsPerPage": 3,
+                "snippets": [
+                    {
+                        "position": 3,
+                        "info": "str"
+                    },
+                    {
+                        "position": 5,
+                        "info": "txt"
+                    }
+                ]
+            },
+            "items": [
+                {
+                    "kind": "asd",
+                    "id": "zxc",
+                    "snippet": {
+                        "position": 2,
+                        "info": "qwe"
+                    }
+                }
+            ]
+        }
+        """.trimIndent()
+
+    val df = DataFrame.readJsonStr(json)
+
+    val typed = df.cast<DataRecord>()
+
+    @Test
+    fun `marker is reused`() {
+        val codeGen = ReplCodeGenerator.create()
+        codeGen.process(DataRecord::class)
+        codeGen.process(typed, ::typed).hasConverter shouldBe false
+        val generated = codeGen.process(df, ::df)
+        generated.declarations.split("\n").size shouldBe 1
+    }
+
+    val modified = df.add("new") { 4 }
+
+    @Test
+    fun `marker is implemented`() {
+        val codeGen = ReplCodeGenerator.create()
+        codeGen.process(DataRecord::class)
+        val generated = codeGen.process(modified, ::modified)
+        generated.declarations.contains(DataRecord::class.simpleName!!) shouldBe true
+    }
+
+    @Test
+    fun printSchema() {
+        val res = df.generateCode(false, true)
+        println(res)
+    }
+}
diff --git a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/codeGen/NameGenerationTests.kt b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/codeGen/NameGenerationTests.kt
new file mode 100644
index 000000000..87e97df68
--- /dev/null
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/codeGen/NameGenerationTests.kt
@@ -0,0 +1,64 @@
+package org.jetbrains.kotlinx.dataframe.codeGen
+
+import io.kotest.matchers.shouldBe
+import org.jetbrains.dataframe.impl.codeGen.CodeGenerator
+import org.jetbrains.dataframe.impl.codeGen.ReplCodeGenerator
+import org.jetbrains.dataframe.impl.codeGen.process
+import org.jetbrains.kotlinx.dataframe.annotations.ColumnName
+import org.jetbrains.kotlinx.dataframe.annotations.DataSchema
+import org.jetbrains.kotlinx.dataframe.api.dataFrameOf
+import org.jetbrains.kotlinx.dataframe.api.schema
+import org.junit.Test
+
+class NameGenerationTests {
+
+    val df = dataFrameOf("first column", "second_column", "____")(3, 5, 7)
+
+    @Test
+    fun `interface generation`() {
+        val codeGen = CodeGenerator.create()
+        val code = codeGen.generate(
+            schema = df.schema(),
+            name = "DataType",
+            fields = true,
+            extensionProperties = false,
+            isOpen = false,
+            visibility = MarkerVisibility.IMPLICIT_PUBLIC,
+            knownMarkers = emptyList(),
+        ).code
+
+        val expected =
+            """
+            @DataSchema(isOpen = false)
+            interface DataType {
+                @ColumnName("____")
+                val `____`: kotlin.Int
+                @ColumnName("first column")
+                val `first column`: kotlin.Int
+                val second_column: kotlin.Int
+            }
+            """.trimIndent()
+
+        code.declarations shouldBe expected
+    }
+
+    @Suppress("ktlint:standard:property-naming")
+    @DataSchema
+    interface DataRecord {
+        @ColumnName("first column")
+        val `first column`: Int
+
+        @ColumnName("second column")
+        val `second column`: Int
+    }
+
+    @Test
+    fun `properties generation`() {
+        val codeGen = ReplCodeGenerator.create()
+        val code = codeGen.process<DataRecord>().split("\n")
+        code.size shouldBe 8
+        code.forEach {
+            it.count { it == '`' } shouldBe 2
+        }
+    }
+}
diff --git a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/codeGen/ReplCodeGenTests.kt b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/codeGen/ReplCodeGenTests.kt
new file mode 100644
index 000000000..30eb99e55
--- /dev/null
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/codeGen/ReplCodeGenTests.kt
@@ -0,0 +1,221 @@
+package org.jetbrains.kotlinx.dataframe.codeGen
+
+import io.kotest.matchers.shouldBe
+import io.kotest.matchers.string.shouldNotBeEmpty
+import org.jetbrains.dataframe.impl.codeGen.ReplCodeGenerator
+import org.jetbrains.dataframe.impl.codeGen.process
+import org.jetbrains.kotlinx.dataframe.ColumnsContainer
+import org.jetbrains.kotlinx.dataframe.DataColumn
+import org.jetbrains.kotlinx.dataframe.DataRow
+import org.jetbrains.kotlinx.dataframe.annotations.DataSchema
+import org.jetbrains.kotlinx.dataframe.api.dataFrameOf
+import org.jetbrains.kotlinx.dataframe.api.filter
+import org.jetbrains.kotlinx.dataframe.api.select
+import org.jetbrains.kotlinx.dataframe.impl.codeGen.ReplCodeGeneratorImpl
+import org.jetbrains.kotlinx.dataframe.testSets.person.BaseTest
+import org.jetbrains.kotlinx.dataframe.testSets.person.city
+import org.jetbrains.kotlinx.dataframe.testSets.person.weight
+import org.junit.Test
+
+@Suppress("ktlint:standard:class-naming")
+class ReplCodeGenTests : BaseTest() {
+
+    val dfName = (ColumnsContainer::class).simpleName!!
+    val dfRowName = (DataRow::class).simpleName!!
+    val dataCol = (DataColumn::class).simpleName!!
+    val intName = Int::class.simpleName!!
+    val stringName = String::class.simpleName!!
+
+    class Test1 {
+        @DataSchema
+        interface _DataFrameType
+
+        @DataSchema(isOpen = false)
+        interface _DataFrameType1 : _DataFrameType
+
+        @DataSchema(isOpen = false)
+        interface _DataFrameType2 : _DataFrameType
+    }
+
+    class Test2 {
+        @DataSchema
+        interface _DataFrameType
+
+        @DataSchema
+        interface _DataFrameType1
+
+        @DataSchema(isOpen = false)
+        interface _DataFrameType2 :
+            _DataFrameType,
+            _DataFrameType1
+    }
+
+    object Test3 {
+        @DataSchema
+        interface A {
+            val x: List<*>
+        }
+
+        @DataSchema
+        interface B : A
+
+        @DataSchema(isOpen = false)
+        interface C : B {
+            override val x: List<Int>
+        }
+
+        @DataSchema
+        interface D : A
+
+        val df = dataFrameOf("x")(listOf(1))
+    }
+
+    @Test
+    fun `process derived markers`() {
+        val repl = ReplCodeGenerator.create()
+        val code = repl.process(df).declarations
+
+        val marker = ReplCodeGeneratorImpl.markerInterfacePrefix
+        val markerFull = Test1._DataFrameType::class.qualifiedName!!
+
+        val expected =
+            """
+            @DataSchema
+            interface $marker { }
+            
+            val $dfName<$marker>.age: $dataCol<$intName> @JvmName("${marker}_age") get() = this["age"] as $dataCol<$intName>
+            val $dfRowName<$marker>.age: $intName @JvmName("${marker}_age") get() = this["age"] as $intName
+            val $dfName<$marker>.city: $dataCol<$stringName?> @JvmName("${marker}_city") get() = this["city"] as $dataCol<$stringName?>
+            val $dfRowName<$marker>.city: $stringName? @JvmName("${marker}_city") get() = this["city"] as $stringName?
+            val $dfName<$marker>.name: $dataCol<$stringName> @JvmName("${marker}_name") get() = this["name"] as $dataCol<$stringName>
+            val $dfRowName<$marker>.name: $stringName @JvmName("${marker}_name") get() = this["name"] as $stringName
+            val $dfName<$marker>.weight: $dataCol<$intName?> @JvmName("${marker}_weight") get() = this["weight"] as $dataCol<$intName?>
+            val $dfRowName<$marker>.weight: $intName? @JvmName("${marker}_weight") get() = this["weight"] as $intName?
+            """.trimIndent()
+        code shouldBe expected
+
+        val code2 = repl.process<Test1._DataFrameType>()
+        code2 shouldBe ""
+
+        val df3 = typed.filter { city != null }
+        val code3 = repl.process(df3).declarations
+        val marker3 = marker + "1"
+        val expected3 =
+            """
+            @DataSchema
+            interface $marker3 : $markerFull { }
+            
+            val $dfName<$marker3>.city: $dataCol<$stringName> @JvmName("${marker3}_city") get() = this["city"] as $dataCol<$stringName>
+            val $dfRowName<$marker3>.city: $stringName @JvmName("${marker3}_city") get() = this["city"] as $stringName
+            """.trimIndent()
+
+        code3 shouldBe expected3
+
+        val code4 = repl.process<Test1._DataFrameType1>()
+        code4 shouldBe ""
+
+        val df5 = typed.filter { weight != null }
+        val code5 = repl.process(df5).declarations
+        val marker5 = marker + "2"
+        val expected5 =
+            """
+            @DataSchema
+            interface $marker5 : $markerFull { }
+            
+            val $dfName<$marker5>.weight: $dataCol<$intName> @JvmName("${marker5}_weight") get() = this["weight"] as $dataCol<$intName>
+            val $dfRowName<$marker5>.weight: $intName @JvmName("${marker5}_weight") get() = this["weight"] as $intName
+            """.trimIndent()
+        code5 shouldBe expected5
+
+        val code6 = repl.process<Test1._DataFrameType2>()
+        code6 shouldBe ""
+    }
+
+    @Test
+    fun `process markers union`() {
+        val repl = ReplCodeGenerator.create()
+        repl.process(typed.select { age and name })
+        repl.process<Test2._DataFrameType>() shouldBe ""
+        repl.process(typed.select { city and weight })
+        repl.process<Test2._DataFrameType1>() shouldBe ""
+
+        val expected =
+            """
+            @DataSchema
+            interface ${Test2._DataFrameType2::class.simpleName!!} : ${Test2._DataFrameType::class.qualifiedName}, ${Test2._DataFrameType1::class.qualifiedName} { }
+            
+            """.trimIndent()
+
+        val code = repl.process(typed).declarations.trimIndent()
+        code shouldBe expected
+    }
+
+    @Test
+    fun `process wrong marker inheritance`() {
+        val repl = ReplCodeGenerator.create()
+        repl.process(typed.select { age and name })
+        repl.process<Test2._DataFrameType>() shouldBe ""
+        repl.process(typed.select { city and weight })
+        // processed wrong marker (doesn't implement Test2.DataFrameType)
+        repl.process<Test1._DataFrameType1>() shouldBe ""
+
+        val marker = Test2._DataFrameType2::class.simpleName!!
+        val expected =
+            """
+            @DataSchema
+            interface $marker : ${Test2._DataFrameType::class.qualifiedName} { }
+            
+            val $dfName<$marker>.city: $dataCol<$stringName?> @JvmName("${marker}_city") get() = this["city"] as $dataCol<$stringName?>
+            val $dfRowName<$marker>.city: $stringName? @JvmName("${marker}_city") get() = this["city"] as $stringName?
+            val $dfName<$marker>.weight: $dataCol<$intName?> @JvmName("${marker}_weight") get() = this["weight"] as $dataCol<$intName?>
+            val $dfRowName<$marker>.weight: $intName? @JvmName("${marker}_weight") get() = this["weight"] as $intName?
+            """.trimIndent()
+
+        val code = repl.process(typed).declarations.trimIndent()
+        code shouldBe expected
+    }
+
+    @Test
+    fun `process overridden property`() {
+        val repl = ReplCodeGenerator.create()
+        repl.process<Test3.A>()
+        repl.process<Test3.B>()
+        repl.process<Test3.C>()
+        val c = repl.process(Test3.df, Test3::df)
+        c.declarations.shouldNotBeEmpty()
+    }
+
+    @Test
+    fun `process diamond inheritance`() {
+        val repl = ReplCodeGenerator.create()
+        repl.process<Test3.A>()
+        repl.process<Test3.B>()
+        repl.process<Test3.D>()
+        val c = repl.process(Test3.df, Test3::df)
+        """val .*ColumnsContainer<\w*>.x:""".toRegex().findAll(c.declarations).count() shouldBe 1
+    }
+
+    object Test4 {
+
+        @DataSchema
+        interface A {
+            val a: Int?
+        }
+
+        @DataSchema
+        interface B {
+            val a: Int?
+        }
+
+        val df = dataFrameOf("a")(1)
+    }
+
+    @Test
+    fun `process duplicate override`() {
+        val repl = ReplCodeGenerator.create()
+        repl.process<Test4.A>()
+        repl.process<Test4.B>()
+        val c = repl.process(Test4.df, Test4::df)
+        """val .*ColumnsContainer<\w*>.a:""".toRegex().findAll(c.declarations).count() shouldBe 1
+    }
+}
diff --git a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/codeGen/ShortNamesRenderingTest.kt b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/codeGen/ShortNamesRenderingTest.kt
new file mode 100644
index 000000000..57e13be92
--- /dev/null
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/codeGen/ShortNamesRenderingTest.kt
@@ -0,0 +1,149 @@
+package org.jetbrains.kotlinx.dataframe.internal.codeGen
+
+import io.kotest.assertions.asClue
+import io.kotest.matchers.shouldBe
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.DataRow
+import org.jetbrains.kotlinx.dataframe.annotations.DataSchema
+import org.jetbrains.kotlinx.dataframe.codeGen.MarkersExtractor
+import org.jetbrains.kotlinx.dataframe.impl.codeGen.ShortNames
+import org.jetbrains.kotlinx.dataframe.impl.codeGen.TypeRenderingStrategy
+import org.junit.Test
+
+internal class ShortNamesRenderingTest : TypeRenderingStrategy by ShortNames {
+
+    interface Marker
+
+    @DataSchema
+    interface DataSchemaMarker
+
+    interface A {
+        val a: DataSchemaMarker
+        val b: Int
+        val c: List<DataSchemaMarker>
+        val d: () -> Unit
+        val e: DataRow<Marker>
+        val f: DataFrame<Marker>
+    }
+
+    private val fields by lazy {
+        MarkersExtractor.get(A::class).allFields.associateBy { it.fieldName.unquoted }
+    }
+
+    @Test
+    fun `data schema type`() {
+        fields.keys.asClue {
+            fields["a"]!!.renderAccessorFieldType() shouldBe
+                "DataRow<org.jetbrains.kotlinx.dataframe.internal.codeGen.ShortNamesRenderingTest.DataSchemaMarker>"
+            fields["a"]!!.renderFieldType() shouldBe
+                "org.jetbrains.kotlinx.dataframe.internal.codeGen.ShortNamesRenderingTest.DataSchemaMarker"
+        }
+    }
+
+    @Test
+    fun `builtin type`() {
+        fields.keys.asClue {
+            fields["b"]!!.renderAccessorFieldType() shouldBe "Int"
+            fields["b"]!!.renderFieldType() shouldBe "Int"
+        }
+    }
+
+    @Test
+    fun `list parametrized by data schema type`() {
+        fields.keys.asClue {
+            fields["c"]!!.renderAccessorFieldType() shouldBe
+                "DataFrame<org.jetbrains.kotlinx.dataframe.internal.codeGen.ShortNamesRenderingTest.DataSchemaMarker>"
+            fields["c"]!!.renderFieldType() shouldBe
+                "List<org.jetbrains.kotlinx.dataframe.internal.codeGen.ShortNamesRenderingTest.DataSchemaMarker>"
+        }
+    }
+
+    @Test
+    fun `short functional types are not supported`() {
+        fields.keys.asClue {
+            fields["d"]!!.renderAccessorFieldType() shouldBe "() -> kotlin.Unit"
+            fields["d"]!!.renderFieldType() shouldBe "() -> kotlin.Unit"
+        }
+    }
+
+    @Test
+    fun `data row`() {
+        fields.keys.asClue {
+            fields["e"]!!.renderAccessorFieldType() shouldBe
+                "DataRow<org.jetbrains.kotlinx.dataframe.internal.codeGen.ShortNamesRenderingTest.Marker>"
+            fields["e"]!!.renderFieldType() shouldBe
+                "DataRow<org.jetbrains.kotlinx.dataframe.internal.codeGen.ShortNamesRenderingTest.Marker>"
+        }
+    }
+
+    @Test
+    fun `data frame`() {
+        fields.keys.asClue {
+            fields["f"]!!.renderAccessorFieldType() shouldBe
+                "DataFrame<org.jetbrains.kotlinx.dataframe.internal.codeGen.ShortNamesRenderingTest.Marker>"
+            fields["f"]!!.renderFieldType() shouldBe
+                "DataFrame<org.jetbrains.kotlinx.dataframe.internal.codeGen.ShortNamesRenderingTest.Marker>"
+        }
+    }
+
+    @Test
+    fun `column for data schema type`() {
+        fields.keys.asClue {
+            fields["a"]!!.renderColumnType() shouldBe
+                "ColumnGroup<org.jetbrains.kotlinx.dataframe.internal.codeGen.ShortNamesRenderingTest.DataSchemaMarker>"
+        }
+    }
+
+    @Test
+    fun `builtin type column`() {
+        fields.keys.asClue {
+            fields["b"]!!.renderColumnType() shouldBe "DataColumn<Int>"
+        }
+    }
+
+    @Test
+    fun `column for list parametrized by data schema type`() {
+        fields.keys.asClue {
+            fields["c"]!!.renderColumnType() shouldBe
+                "DataColumn<DataFrame<org.jetbrains.kotlinx.dataframe.internal.codeGen.ShortNamesRenderingTest.DataSchemaMarker>>"
+        }
+    }
+
+    @Test
+    fun `functional type column`() {
+        fields.keys.asClue {
+            fields["d"]!!.renderColumnType() shouldBe "DataColumn<() -> kotlin.Unit>"
+        }
+    }
+
+    @Test
+    fun `data row column`() {
+        fields.keys.asClue {
+            fields["e"]!!.renderColumnType() shouldBe
+                "ColumnGroup<org.jetbrains.kotlinx.dataframe.internal.codeGen.ShortNamesRenderingTest.Marker>"
+        }
+    }
+
+    @Test
+    fun `data frame column`() {
+        fields.keys.asClue {
+            fields["f"]!!.renderColumnType() shouldBe
+                "DataColumn<DataFrame<org.jetbrains.kotlinx.dataframe.internal.codeGen.ShortNamesRenderingTest.Marker>>"
+        }
+    }
+
+    interface GenericDataSchema<A> {
+        val a: A
+    }
+
+    @Test
+    fun `generic field`() {
+        MarkersExtractor.get(GenericDataSchema::class).allFields[0].renderAccessorFieldType() shouldBe "A"
+        MarkersExtractor.get(GenericDataSchema::class).allFields[0].renderFieldType() shouldBe "A"
+    }
+
+    @Test
+    fun `generic column`() {
+        MarkersExtractor.get(GenericDataSchema::class).allFields[0].renderColumnType() shouldBe "DataColumn<A>"
+    }
+}
diff --git a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/columns/ColumnGroups.kt b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/columns/ColumnGroups.kt
new file mode 100644
index 000000000..5169e7c1c
--- /dev/null
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/columns/ColumnGroups.kt
@@ -0,0 +1,19 @@
+package org.jetbrains.kotlinx.dataframe.columns
+
+import io.kotest.matchers.shouldBe
+import org.jetbrains.kotlinx.dataframe.DataColumn
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.junit.Test
+
+class ColumnGroupTests {
+
+    @Test
+    fun emptyColumnGroup() {
+        val df = DataFrame.empty(2)
+        val group = DataColumn.createColumnGroup("a", df)
+        group.size() shouldBe 2
+        group.columnsCount() shouldBe 0
+        group.rowsCount() shouldBe 2
+        group.distinct().rowsCount() shouldBe 0
+    }
+}
diff --git a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/columns/DataColumns.kt b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/columns/DataColumns.kt
new file mode 100644
index 000000000..6061b8aba
--- /dev/null
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/columns/DataColumns.kt
@@ -0,0 +1,31 @@
+package org.jetbrains.kotlinx.dataframe.columns
+
+import io.kotest.matchers.shouldBe
+import org.jetbrains.kotlinx.dataframe.api.toColumn
+import org.jetbrains.kotlinx.dataframe.api.toDataFrame
+import org.junit.Test
+import java.net.URI
+
+class DataColumns {
+    @Test
+    fun `create column with platform type from Api`() {
+        val df1 = listOf(1, 2, 3).toDataFrame {
+            expr { URI.create("http://example.com") } into "text"
+        }
+        df1["text"].type().toString() shouldBe "java.net.URI"
+    }
+
+    @Test
+    fun `create column with nullable platform type from Api`() {
+        val df1 = listOf(1, 2, 3).toDataFrame {
+            expr { i -> URI.create("http://example.com").takeIf { i == 2 } } into "text"
+        }
+        df1["text"].type().toString() shouldBe "java.net.URI?"
+    }
+
+    @Test
+    fun `create column with nullable platform type from factory method`() {
+        val col = listOf(URI.create("http://example.com"), null).toColumn("a")
+        col.type().toString() shouldBe "java.net.URI?"
+    }
+}
diff --git a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/explainer/PluginCallbackProxy.kt b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/explainer/PluginCallbackProxy.kt
new file mode 100644
index 000000000..0f6cafbbe
--- /dev/null
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/explainer/PluginCallbackProxy.kt
@@ -0,0 +1,342 @@
+package org.jetbrains.kotlinx.dataframe.explainer
+
+import org.jetbrains.kotlinx.dataframe.AnyCol
+import org.jetbrains.kotlinx.dataframe.AnyFrame
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.DataRow
+import org.jetbrains.kotlinx.dataframe.RowValueFilter
+import org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl
+import org.jetbrains.kotlinx.dataframe.api.Convert
+import org.jetbrains.kotlinx.dataframe.api.FormattedFrame
+import org.jetbrains.kotlinx.dataframe.api.Gather
+import org.jetbrains.kotlinx.dataframe.api.GroupBy
+import org.jetbrains.kotlinx.dataframe.api.Merge
+import org.jetbrains.kotlinx.dataframe.api.Pivot
+import org.jetbrains.kotlinx.dataframe.api.PivotGroupBy
+import org.jetbrains.kotlinx.dataframe.api.ReducedPivot
+import org.jetbrains.kotlinx.dataframe.api.ReducedPivotGroupBy
+import org.jetbrains.kotlinx.dataframe.api.Split
+import org.jetbrains.kotlinx.dataframe.api.SplitWithTransform
+import org.jetbrains.kotlinx.dataframe.api.Update
+import org.jetbrains.kotlinx.dataframe.api.format
+import org.jetbrains.kotlinx.dataframe.api.frames
+import org.jetbrains.kotlinx.dataframe.api.into
+import org.jetbrains.kotlinx.dataframe.api.toDataFrame
+import org.jetbrains.kotlinx.dataframe.api.values
+import org.jetbrains.kotlinx.dataframe.api.where
+import org.jetbrains.kotlinx.dataframe.api.with
+import org.jetbrains.kotlinx.dataframe.columns.ColumnsResolver
+import org.jetbrains.kotlinx.dataframe.io.DataFrameHtmlData
+import org.jetbrains.kotlinx.dataframe.io.sessionId
+import org.jetbrains.kotlinx.dataframe.io.tableInSessionId
+import org.jetbrains.kotlinx.dataframe.io.toHTML
+import java.io.File
+
+annotation class TransformDataFrameExpressions
+
+fun interface PluginCallback {
+    fun doAction(
+        source: String,
+        name: String,
+        df: Any,
+        id: String,
+        receiverId: String?,
+        containingClassFqName: String?,
+        containingFunName: String?,
+        statementIndex: Int,
+    )
+}
+
+object PluginCallbackProxy : PluginCallback {
+    val names = mutableMapOf<String, List<String>>()
+    val expressionsByStatement = mutableMapOf<Int, List<Expression>>()
+
+    private var manualOutput: DataFrameHtmlData? = null
+
+    fun overrideHtmlOutput(manualOutput: DataFrameHtmlData) {
+        this.manualOutput = manualOutput
+    }
+
+    data class Expression(
+        val source: String,
+        val containingClassFqName: String?,
+        val containingFunName: String?,
+        val df: Any,
+    )
+
+    fun start() {
+        expressionsByStatement.clear()
+        manualOutput = null
+    }
+
+    fun save() {
+        // ensure stable table ids across test invocation
+        sessionId = 0
+        tableInSessionId = 0
+        var output: DataFrameHtmlData
+        val manualOutput = this.manualOutput
+        if (manualOutput == null) {
+            output = DataFrameHtmlData.tableDefinitions() + WritersideStyle
+
+            // make copy to avoid concurrent modification exception
+            val statements = expressionsByStatement.toMap()
+            when (statements.size) {
+                0 -> error("function doesn't have any dataframe expression")
+
+                1 -> {
+                    output += statementOutput(statements.values.single())
+                }
+
+                else -> {
+                    statements.forEach { (index, expressions) ->
+                        var details: DataFrameHtmlData = statementOutput(expressions)
+
+                        details = details.copy(
+                            body =
+                                """
+                                <details>
+                                <summary>${
+                                    expressions.joinToString(".") { it.source }.also {
+                                        if (it.length > 95) {
+                                            TODO(
+                                                "expression is too long ${it.length}. better to split sample in multiple snippets",
+                                            )
+                                        }
+                                    }.escapeHtmlForIFrame()
+                                }</summary>
+                                ${details.body}
+                                </details>
+                                <br>
+                                """.trimIndent(),
+                        )
+                        output += details
+                    }
+                }
+            }
+        } else {
+            output = manualOutput
+        }
+
+        val input = expressionsByStatement.values.first().first()
+        val name = "${input.containingClassFqName}.${input.containingFunName}"
+        val destination = File("build/dataframes").also {
+            it.mkdirs()
+        }
+        output.writeHTML(File(destination, "$name.html"))
+        val korro = File("build/korroOutputLines").also {
+            it.mkdirs()
+        }
+
+        val group = name.substringBefore("_")
+        File(korro, group).writeText(
+            """
+            
+            <dataFrame src="$group.html"/>
+            """.trimIndent(),
+        )
+    }
+
+    private fun List<Expression>.joinToSource(): String = joinToString(".") { it.source }
+
+    private fun statementOutput(expressions: List<Expression>): DataFrameHtmlData {
+        var data = DataFrameHtmlData()
+        val allow = setOf(
+            "toDataFrame",
+            "peek(dataFrameOf(col), dataFrameOf(col))",
+        )
+        if (expressions.isEmpty()) {
+            error("No dataframe expressions in sample")
+        }
+        if (expressions.size == 1) {
+            if (allow.any { expressions[0].source.contains(it) }) {
+                val expression = expressions[0]
+                data += convertToHTML(expression.df)
+            } else {
+                error("${expressions.joinToSource()} Sample without output or input (i.e. function returns some value)")
+            }
+        } else {
+            for ((i, expression) in expressions.withIndex()) {
+                when (i) {
+                    0 -> {
+                        val table = convertToHTML(expression.df)
+                        val description = table.copy(
+                            body =
+                                """
+                                <details>
+                                <summary>Input ${convertToDescription(expression.df)}</summary>
+                                 ${table.body}
+                                </details>
+                                """.trimIndent(),
+                        )
+                        data += description
+                    }
+
+                    expressions.lastIndex -> {
+                        val table = convertToHTML(expression.df)
+                        val description = table.copy(
+                            body =
+                                """
+                                <details>
+                                <summary>Output ${convertToDescription(expression.df)}</summary>
+                                 ${table.body}
+                                </details>
+                                """.trimIndent(),
+                        )
+                        data += description
+                    }
+
+                    else -> {
+                        val table = convertToHTML(expression.df)
+                        val description = table.copy(
+                            body =
+                                """
+                                <details>
+                                <summary>Step $i: ${convertToDescription(expression.df)}</summary>
+                                 ${table.body}
+                                </details>
+                                """.trimIndent(),
+                        )
+                        data += description
+                    }
+                }
+            }
+        }
+        return data
+    }
+
+    var action: PluginCallback =
+        PluginCallback { source, name, df, id, receiverId, containingClassFqName, containingFunName, statementIndex ->
+            expressionsByStatement.compute(statementIndex) { _, list ->
+                val element = Expression(source, containingClassFqName, containingFunName, df)
+                list?.plus(element) ?: listOf(element)
+            }
+        }
+
+    override fun doAction(
+        source: String,
+        name: String,
+        df: Any,
+        id: String,
+        receiverId: String?,
+        containingClassFqName: String?,
+        containingFunName: String?,
+        statementIndex: Int,
+    ) {
+        action.doAction(source, name, df, id, receiverId, containingClassFqName, containingFunName, statementIndex)
+    }
+}
+
+private fun convertToHTML(dataframeLike: Any): DataFrameHtmlData {
+    fun DataFrame<*>.toHTML() = toHTML(SamplesDisplayConfiguration, getFooter = WritersideFooter)
+
+    fun FormattedFrame<*>.toHTML1() = toHTML(SamplesDisplayConfiguration)
+
+    return when (dataframeLike) {
+        is Pivot<*> -> dataframeLike.frames().toDataFrame().toHTML()
+
+        is ReducedPivot<*> -> dataframeLike.values().toDataFrame().toHTML()
+
+        is PivotGroupBy<*> -> dataframeLike.frames().toHTML()
+
+        is ReducedPivotGroupBy<*> -> dataframeLike.values().toHTML()
+
+        is SplitWithTransform<*, *, *> -> dataframeLike.into().toHTML()
+
+        is Merge<*, *, *> -> dataframeLike.into("merged").toHTML()
+
+        is Gather<*, *, *, *> -> dataframeLike.into("key", "value").toHTML()
+
+        is Update<*, *> ->
+            dataframeLike.df.let {
+                var it = it.format(
+                    dataframeLike.columns as ColumnsSelectionDsl<Any?>.(
+                        it: ColumnsSelectionDsl<Any?>,
+                    ) -> ColumnsResolver<*>,
+                )
+                if (dataframeLike.filter != null) {
+                    it = it.where(dataframeLike.filter as RowValueFilter<Any?, Any?>)
+                }
+                it.with {
+                    background(rgb(152, 251, 152))
+                }
+            }.toHTML1()
+
+        is Convert<*, *> -> DataFrameHtmlData(body = "<p>${dataframeLike::class}</p>")
+
+        is FormattedFrame<*> -> dataframeLike.toHTML1()
+
+        is GroupBy<*, *> -> dataframeLike.toDataFrame().toHTML()
+
+        is AnyFrame -> dataframeLike.toHTML()
+
+        is AnyCol -> dataframeLike.toDataFrame().toHTML()
+
+        is DataRow<*> -> dataframeLike.toDataFrame().toHTML()
+
+        is Split<*, *> -> dataframeLike.toDataFrame().toHTML()
+
+        else -> throw IllegalArgumentException("Unsupported type: ${dataframeLike::class}")
+    }
+}
+
+private fun convertToDescription(dataframeLike: Any): String =
+    when (dataframeLike) {
+        is AnyFrame -> dataframeLike.let {
+            "DataFrame: rowsCount = ${it.rowsCount()}, columnsCount = ${it.columnsCount()}"
+        }
+
+        is Pivot<*> -> "Pivot"
+
+        is ReducedPivot<*> -> "ReducedPivot"
+
+        is PivotGroupBy<*> -> "PivotGroupBy"
+
+        is ReducedPivotGroupBy<*> -> "ReducedPivotGroupBy"
+
+        is SplitWithTransform<*, *, *> -> "SplitWithTransform"
+
+        is Split<*, *> -> "Split"
+
+        is Merge<*, *, *> -> "Merge"
+
+        is Gather<*, *, *, *> -> "Gather"
+
+        is Update<*, *> -> "Update"
+
+        is Convert<*, *> -> "Convert"
+
+        is FormattedFrame<*> -> "FormattedFrame"
+
+        is GroupBy<*, *> -> "GroupBy"
+
+        is DataRow<*> -> "DataRow"
+
+        else -> throw IllegalArgumentException("Unsupported type: ${dataframeLike::class}")
+    }.escapeHtmlForIFrame()
+
+internal fun String.escapeHtmlForIFrame(): String {
+    val str = this
+    return buildString {
+        for (c in str) {
+            when {
+                c.code > 127 || c == '\'' || c == '\\' -> {
+                    append("&#")
+                    append(c.code)
+                    append(';')
+                }
+
+                c == '"' -> append("&quot;")
+
+                c == '<' -> append("&amp;lt;")
+
+                c == '>' -> append("&amp;gt;")
+
+                c == '&' -> append("&amp;")
+
+                else -> {
+                    append(c)
+                }
+            }
+        }
+    }
+}
diff --git a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/explainer/SampleAggregator.kt b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/explainer/SampleAggregator.kt
new file mode 100644
index 000000000..73ed43ca4
--- /dev/null
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/explainer/SampleAggregator.kt
@@ -0,0 +1,22 @@
+package org.jetbrains.kotlinx.dataframe.explainer
+
+import java.io.File
+
+fun main() {
+    File("build/dataframes")
+        .walkTopDown()
+        .filter {
+            it.nameWithoutExtension.startsWith("org.jetbrains")
+        }
+        // org.ClassName.functionName_properties
+        // <dataFrame src="org.jetbrains.kotlinx.dataframe.samples.api.Modify.addDfs.html"/>
+        .groupBy {
+            it.nameWithoutExtension.substringBefore("_")
+        }.mapValues { (name, files) ->
+            val target = File("../docs/StardustDocs/snippets")
+            val original = files
+                .firstOrNull { it.nameWithoutExtension.contains("properties") }
+                ?: files.first()
+            original.copyTo(File(target, "$name.html"), overwrite = true)
+        }
+}
diff --git a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/explainer/SamplesRenderingUtils.kt b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/explainer/SamplesRenderingUtils.kt
new file mode 100644
index 000000000..9c4968e1d
--- /dev/null
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/explainer/SamplesRenderingUtils.kt
@@ -0,0 +1,37 @@
+package org.jetbrains.kotlinx.dataframe.explainer
+
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.io.DataFrameHtmlData
+import org.jetbrains.kotlinx.dataframe.io.DisplayConfiguration
+
+val SamplesDisplayConfiguration = DisplayConfiguration(enableFallbackStaticTables = false)
+
+val WritersideStyle = DataFrameHtmlData(
+    // copy writerside stlyles
+    style =
+        """
+        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;
+        }
+        """.trimIndent(),
+)
+
+val WritersideFooter: (DataFrame<*>) -> String = { "" }
diff --git a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/io/CsvTests.kt b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/io/CsvTests.kt
new file mode 100644
index 000000000..d221cee58
--- /dev/null
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/io/CsvTests.kt
@@ -0,0 +1,327 @@
+package org.jetbrains.kotlinx.dataframe.io
+
+import io.kotest.assertions.throwables.shouldNotThrowAny
+import io.kotest.matchers.nulls.shouldNotBeNull
+import io.kotest.matchers.shouldBe
+import kotlinx.datetime.LocalDateTime
+import org.apache.commons.csv.CSVFormat
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.api.ParserOptions
+import org.jetbrains.kotlinx.dataframe.api.allNulls
+import org.jetbrains.kotlinx.dataframe.api.convert
+import org.jetbrains.kotlinx.dataframe.api.dataFrameOf
+import org.jetbrains.kotlinx.dataframe.api.group
+import org.jetbrains.kotlinx.dataframe.api.groupBy
+import org.jetbrains.kotlinx.dataframe.api.into
+import org.jetbrains.kotlinx.dataframe.api.isEmpty
+import org.jetbrains.kotlinx.dataframe.api.schema
+import org.jetbrains.kotlinx.dataframe.api.toStr
+import org.jetbrains.kotlinx.dataframe.ncol
+import org.jetbrains.kotlinx.dataframe.nrow
+import org.jetbrains.kotlinx.dataframe.testCsv
+import org.jetbrains.kotlinx.dataframe.testResource
+import org.junit.Test
+import java.io.File
+import java.io.StringWriter
+import java.net.URL
+import java.util.Locale
+import kotlin.reflect.KClass
+import kotlin.reflect.typeOf
+
+@Suppress("ktlint:standard:argument-list-wrapping")
+class CsvTests {
+
+    @Test
+    fun readNulls() {
+        val src =
+            """
+            first,second
+            2,,
+            3,,
+            """.trimIndent()
+        val df = DataFrame.readDelimStr(src)
+        df.nrow shouldBe 2
+        df.ncol shouldBe 2
+        df["first"].type() shouldBe typeOf<Int>()
+        df["second"].allNulls() shouldBe true
+        df["second"].type() shouldBe typeOf<String?>()
+    }
+
+    @Test
+    fun write() {
+        val df = dataFrameOf("col1", "col2")(
+            1, null,
+            2, null,
+        ).convert("col2").toStr()
+
+        val str = StringWriter()
+        df.writeCSV(str)
+
+        val res = DataFrame.readDelimStr(str.buffer.toString())
+
+        res shouldBe df
+    }
+
+    @Test
+    fun readCSV() {
+        val df = DataFrame.read(simpleCsv)
+
+        df.ncol shouldBe 11
+        df.nrow shouldBe 5
+        df.columnNames()[5] shouldBe "duplicate1"
+        df.columnNames()[6] shouldBe "duplicate11"
+        df["duplicate1"].type() shouldBe typeOf<String?>()
+        df["double"].type() shouldBe typeOf<Double?>()
+        df["time"].type() shouldBe typeOf<LocalDateTime>()
+
+        println(df)
+    }
+
+    @Test
+    fun readCsvWithFrenchLocaleAndAlternativeDelimiter() {
+        val df = DataFrame.readCSV(
+            url = csvWithFrenchLocale,
+            delimiter = ';',
+            parserOptions = ParserOptions(locale = Locale.FRENCH),
+        )
+
+        df.ncol shouldBe 11
+        df.nrow shouldBe 5
+        df.columnNames()[5] shouldBe "duplicate1"
+        df.columnNames()[6] shouldBe "duplicate11"
+        df["duplicate1"].type() shouldBe typeOf<String?>()
+        df["double"].type() shouldBe typeOf<Double?>()
+        df["number"].type() shouldBe typeOf<Double>()
+        df["time"].type() shouldBe typeOf<LocalDateTime>()
+
+        println(df)
+    }
+
+    @Test
+    fun readCsvWithFloats() {
+        val df = DataFrame.readCSV(wineCsv, delimiter = ';')
+        val schema = df.schema()
+
+        fun assertColumnType(columnName: String, kClass: KClass<*>) {
+            val col = schema.columns[columnName]
+            col.shouldNotBeNull()
+            col.type.classifier shouldBe kClass
+        }
+
+        assertColumnType("citric acid", Double::class)
+        assertColumnType("alcohol", Double::class)
+        assertColumnType("quality", Int::class)
+    }
+
+    @Test
+    fun `read standard CSV with floats when user has alternative locale`() {
+        val currentLocale = Locale.getDefault()
+        try {
+            Locale.setDefault(Locale.forLanguageTag("ru-RU"))
+            val df = DataFrame.readCSV(wineCsv, delimiter = ';')
+            val schema = df.schema()
+
+            fun assertColumnType(columnName: String, kClass: KClass<*>) {
+                val col = schema.columns[columnName]
+                col.shouldNotBeNull()
+                col.type.classifier shouldBe kClass
+            }
+
+            assertColumnType("citric acid", Double::class)
+            assertColumnType("alcohol", Double::class)
+            assertColumnType("quality", Int::class)
+        } finally {
+            Locale.setDefault(currentLocale)
+        }
+    }
+
+    @Test
+    fun `read with custom header`() {
+        val header = ('A'..'K').map { it.toString() }
+        val df = DataFrame.readCSV(simpleCsv, header = header, skipLines = 1)
+        df.columnNames() shouldBe header
+        df["B"].type() shouldBe typeOf<Int>()
+
+        val headerShort = ('A'..'E').map { it.toString() }
+        val dfShort = DataFrame.readCSV(simpleCsv, header = headerShort, skipLines = 1)
+        dfShort.ncol shouldBe 5
+        dfShort.columnNames() shouldBe headerShort
+    }
+
+    @Test
+    fun `read first rows`() {
+        val expected =
+            listOf(
+                "untitled",
+                "user_id",
+                "name",
+                "duplicate",
+                "username",
+                "duplicate1",
+                "duplicate11",
+                "double",
+                "number",
+                "time",
+                "empty",
+            )
+        val dfHeader = DataFrame.readCSV(simpleCsv, readLines = 0)
+        dfHeader.nrow shouldBe 0
+        dfHeader.columnNames() shouldBe expected
+
+        val dfThree = DataFrame.readCSV(simpleCsv, readLines = 3)
+        dfThree.nrow shouldBe 3
+
+        val dfFull = DataFrame.readCSV(simpleCsv, readLines = 10)
+        dfFull.nrow shouldBe 5
+    }
+
+    @Test
+    fun `if string starts with a number, it should be parsed as a string anyway`() {
+        val df = DataFrame.readCSV(durationCsv)
+        df["duration"].type() shouldBe typeOf<String>()
+        df["floatDuration"].type() shouldBe typeOf<String>()
+    }
+
+    @Test
+    fun `if record has fewer columns than header then pad it with nulls`() {
+        val csvContent =
+            """
+            col1,col2,col3
+            568,801,587
+            780,588
+            """.trimIndent()
+
+        val df = shouldNotThrowAny {
+            DataFrame.readDelimStr(csvContent)
+        }
+
+        df shouldBe dataFrameOf("col1", "col2", "col3")(
+            568, 801, 587,
+            780, 588, null,
+        )
+    }
+
+    @Test
+    fun `write and read frame column`() {
+        val df = dataFrameOf("a", "b", "c")(
+            1, 2, 3,
+            1, 3, 2,
+            2, 1, 3,
+        )
+        val grouped = df.groupBy("a").into("g")
+        val str = grouped.toCsv()
+        val res = DataFrame.readDelimStr(str)
+        res shouldBe grouped
+    }
+
+    @Test
+    fun `write and read column group`() {
+        val df = dataFrameOf("a", "b", "c")(
+            1, 2, 3,
+            1, 3, 2,
+        )
+        val grouped = df.group("b", "c").into("d")
+        val str = grouped.toCsv()
+        val res = DataFrame.readDelimStr(str)
+        res shouldBe grouped
+    }
+
+    @Test
+    fun `CSV String of saved dataframe starts with column name`() {
+        val df = dataFrameOf("a")(1)
+        df.toCsv().first() shouldBe 'a'
+    }
+
+    @Test
+    fun `guess tsv`() {
+        val df = DataFrame.read(testResource("abc.tsv"))
+        df.columnsCount() shouldBe 3
+        df.rowsCount() shouldBe 2
+    }
+
+    @Test
+    fun `write csv without header produce correct file`() {
+        val df = dataFrameOf("a", "b", "c")(
+            1, 2, 3,
+            1, 3, 2,
+        )
+        df.writeCSV(
+            "src/test/resources/without_header.csv",
+            CSVFormat.DEFAULT.builder()
+                .setSkipHeaderRecord(true)
+                .build(),
+        )
+        val producedFile = File("src/test/resources/without_header.csv")
+        producedFile.exists() shouldBe true
+        producedFile.readText() shouldBe "1,2,3\r\n1,3,2\r\n"
+        producedFile.delete()
+    }
+
+    @Test
+    fun `check integrity of example data`() {
+        val df = DataFrame.readCSV("../data/jetbrains_repositories.csv")
+        df.columnNames() shouldBe listOf("full_name", "html_url", "stargazers_count", "topics", "watchers")
+        df.columnTypes() shouldBe
+            listOf(typeOf<String>(), typeOf<URL>(), typeOf<Int>(), typeOf<String>(), typeOf<Int>())
+        df shouldBe DataFrame.readCSV("../data/jetbrains repositories.csv")
+    }
+
+    @Test
+    fun `readDelimStr delimiter`() {
+        val tsv =
+            """
+            a	b	c
+            1	2	3
+            """.trimIndent()
+        val df = DataFrame.readDelimStr(tsv, '\t')
+        df shouldBe dataFrameOf("a", "b", "c")(1, 2, 3)
+    }
+
+    @Test
+    fun `file with BOM`() {
+        val df = DataFrame.readCSV(withBomCsv, delimiter = ';')
+        df.columnNames() shouldBe listOf("Column1", "Column2")
+    }
+
+    @Test
+    fun `read empty delimStr or CSV`() {
+        val emptyDelimStr = DataFrame.readDelimStr("")
+        emptyDelimStr shouldBe DataFrame.empty()
+
+        val emptyDelimFile = DataFrame.readDelim(File.createTempFile("empty", "csv").reader())
+        emptyDelimFile shouldBe DataFrame.empty()
+
+        val emptyCsvFile = DataFrame.readCSV(File.createTempFile("empty", "csv"))
+        emptyCsvFile shouldBe DataFrame.empty()
+
+        val emptyCsvFileManualHeader = DataFrame.readCSV(
+            file = File.createTempFile("empty", "csv"),
+            header = listOf("a", "b", "c"),
+        )
+        emptyCsvFileManualHeader.apply {
+            isEmpty() shouldBe true
+            columnNames() shouldBe listOf("a", "b", "c")
+            columnTypes() shouldBe listOf(typeOf<String>(), typeOf<String>(), typeOf<String>())
+        }
+
+        val emptyCsvFileWithHeader = DataFrame.readCSV(
+            file = File.createTempFile("empty", "csv").also { it.writeText("a,b,c") },
+        )
+        emptyCsvFileWithHeader.apply {
+            isEmpty() shouldBe true
+            columnNames() shouldBe listOf("a", "b", "c")
+            columnTypes() shouldBe listOf(typeOf<String>(), typeOf<String>(), typeOf<String>())
+        }
+
+        val emptyTsvStr = DataFrame.readTSV(File.createTempFile("empty", "tsv"))
+        emptyTsvStr shouldBe DataFrame.empty()
+    }
+
+    companion object {
+        private val simpleCsv = testCsv("testCSV")
+        private val csvWithFrenchLocale = testCsv("testCSVwithFrenchLocale")
+        private val wineCsv = testCsv("wine")
+        private val durationCsv = testCsv("duration")
+        private val withBomCsv = testCsv("with-bom")
+    }
+}
diff --git a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/io/ImageSerializationTests.kt b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/io/ImageSerializationTests.kt
new file mode 100644
index 000000000..fe119fc41
--- /dev/null
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/io/ImageSerializationTests.kt
@@ -0,0 +1,180 @@
+package org.jetbrains.kotlinx.dataframe.io
+
+import io.kotest.matchers.shouldBe
+import io.kotest.matchers.string.shouldContain
+import kotlinx.serialization.json.JsonObject
+import kotlinx.serialization.json.jsonArray
+import kotlinx.serialization.json.jsonObject
+import kotlinx.serialization.json.jsonPrimitive
+import org.jetbrains.kotlinx.dataframe.api.dataFrameOf
+import org.jetbrains.kotlinx.dataframe.impl.io.BufferedImageEncoder
+import org.jetbrains.kotlinx.dataframe.impl.io.SerializationKeys.KOTLIN_DATAFRAME
+import org.jetbrains.kotlinx.dataframe.impl.io.resizeKeepingAspectRatio
+import org.jetbrains.kotlinx.dataframe.io.Base64ImageEncodingOptions.Companion.ALL_OFF
+import org.jetbrains.kotlinx.dataframe.io.Base64ImageEncodingOptions.Companion.GZIP_ON
+import org.jetbrains.kotlinx.dataframe.io.Base64ImageEncodingOptions.Companion.LIMIT_SIZE_ON
+import org.jetbrains.kotlinx.dataframe.parseJsonStr
+import org.jetbrains.kotlinx.dataframe.testResource
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.junit.runners.Parameterized
+import java.awt.image.BufferedImage
+import java.io.ByteArrayInputStream
+import java.io.ByteArrayOutputStream
+import java.io.File
+import java.util.Base64
+import java.util.zip.GZIPInputStream
+import javax.imageio.ImageIO
+
+@RunWith(Parameterized::class)
+class ImageSerializationTests(private val encodingOptions: Base64ImageEncodingOptions?) {
+    @Test
+    fun `serialize images as base64`() {
+        val images = readImagesFromResources()
+        val json = encodeImagesAsJson(images, encodingOptions)
+
+        if (encodingOptions == DISABLED) {
+            checkImagesEncodedAsToString(json, images.size)
+            return
+        }
+
+        val decodedImages = decodeImagesFromJson(json, images.size, encodingOptions)
+
+        for ((decodedImage, original) in decodedImages.zip(images)) {
+            val expectedImage = resizeIfNeeded(original, encodingOptions)
+            isImagesIdentical(decodedImage, expectedImage, 2) shouldBe true
+        }
+    }
+
+    private fun readImagesFromResources(): List<BufferedImage> {
+        val dir = File(testResource("imgs").path)
+
+        return dir.listFiles()?.map { file ->
+            try {
+                ImageIO.read(file)
+            } catch (ex: Exception) {
+                throw IllegalArgumentException("Error reading ${file.name}: ${ex.message}")
+            }
+        } ?: emptyList()
+    }
+
+    private fun encodeImagesAsJson(
+        images: List<BufferedImage>,
+        encodingOptions: Base64ImageEncodingOptions?,
+    ): JsonObject {
+        val df = dataFrameOf(listOf("imgs"), images)
+        val jsonStr = df.toJsonWithMetadata(
+            20,
+            nestedRowLimit = 20,
+            customEncoders = listOfNotNull(encodingOptions?.let { BufferedImageEncoder(encodingOptions) }),
+        )
+
+        return parseJsonStr(jsonStr)
+    }
+
+    private fun checkImagesEncodedAsToString(json: JsonObject, numImgs: Int) {
+        for (i in 0..<numImgs) {
+            val row = json[KOTLIN_DATAFRAME]!!.jsonArray[i].jsonObject
+            val img = row["imgs"]?.jsonPrimitive?.content
+
+            img shouldContain "BufferedImage"
+        }
+    }
+
+    private fun decodeImagesFromJson(
+        json: JsonObject,
+        imgsNum: Int,
+        encodingOptions: Base64ImageEncodingOptions,
+    ): List<BufferedImage> {
+        val result = mutableListOf<BufferedImage>()
+        for (i in 0..<imgsNum) {
+            val row = json[KOTLIN_DATAFRAME]!!.jsonArray[i].jsonObject
+            val imgString = row["imgs"]!!.jsonPrimitive.content
+
+            val bytes = decodeBase64Image(imgString, encodingOptions)
+            val decodedImage = createImageFromBytes(bytes)
+
+            result.add(decodedImage)
+        }
+
+        return result
+    }
+
+    private fun decodeBase64Image(imgString: String, encodingOptions: Base64ImageEncodingOptions): ByteArray =
+        when {
+            encodingOptions.isGzipOn -> decompressGzip(Base64.getDecoder().decode(imgString))
+            else -> Base64.getDecoder().decode(imgString)
+        }
+
+    private fun decompressGzip(input: ByteArray): ByteArray =
+        ByteArrayOutputStream().use { byteArrayOutputStream ->
+            GZIPInputStream(input.inputStream()).use { inputStream ->
+                inputStream.copyTo(byteArrayOutputStream)
+            }
+            byteArrayOutputStream.toByteArray()
+        }
+
+    private fun resizeIfNeeded(image: BufferedImage, encodingOptions: Base64ImageEncodingOptions): BufferedImage =
+        when {
+            !encodingOptions.isLimitSizeOn -> image
+            else -> image.resizeKeepingAspectRatio(encodingOptions.imageSizeLimit)
+        }
+
+    private fun createImageFromBytes(bytes: ByteArray): BufferedImage {
+        val bais = ByteArrayInputStream(bytes)
+        return ImageIO.read(bais)
+    }
+
+    private fun isImagesIdentical(img1: BufferedImage, img2: BufferedImage, allowedDelta: Int): Boolean {
+        // First check dimensions
+        if (img1.width != img2.width || img1.height != img2.height) {
+            return false
+        }
+
+        // Then check each pixel
+        for (y in 0 until img1.height) {
+            for (x in 0 until img1.width) {
+                val rgb1 = img1.getRGB(x, y)
+                val rgb2 = img2.getRGB(x, y)
+
+                val r1 = (rgb1 shr 16) and 0xFF
+                val g1 = (rgb1 shr 8) and 0xFF
+                val b1 = rgb1 and 0xFF
+
+                val r2 = (rgb2 shr 16) and 0xFF
+                val g2 = (rgb2 shr 8) and 0xFF
+                val b2 = rgb2 and 0xFF
+
+                val diff = kotlin.math.abs(r1 - r2) + kotlin.math.abs(g1 - g2) + kotlin.math.abs(b1 - b2)
+
+                // If the difference in color components exceed our allowance return false
+                if (diff > allowedDelta) {
+                    return false
+                }
+            }
+        }
+
+        // If no exceeding difference was found, the images are identical within our allowedDelta
+        return true
+    }
+
+    companion object {
+        private val DEFAULT = Base64ImageEncodingOptions()
+        private val GZIP_ON_RESIZE_OFF = Base64ImageEncodingOptions(options = GZIP_ON)
+        private val GZIP_OFF_RESIZE_OFF = Base64ImageEncodingOptions(options = ALL_OFF)
+        private val GZIP_ON_RESIZE_TO_700 =
+            Base64ImageEncodingOptions(imageSizeLimit = 700, options = GZIP_ON or LIMIT_SIZE_ON)
+        private val DISABLED = null
+
+        @JvmStatic
+        @Parameterized.Parameters
+        fun imageEncodingOptionsToTest(): Collection<Base64ImageEncodingOptions?> =
+            listOf(
+                DEFAULT,
+                GZIP_ON_RESIZE_OFF,
+                GZIP_OFF_RESIZE_OFF,
+                GZIP_ON_RESIZE_TO_700,
+                null,
+            )
+    }
+}
diff --git a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/io/ParserTests.kt b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/io/ParserTests.kt
new file mode 100644
index 000000000..6ca02e2f4
--- /dev/null
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/io/ParserTests.kt
@@ -0,0 +1,218 @@
+package org.jetbrains.kotlinx.dataframe.io
+
+import io.kotest.assertions.throwables.shouldThrow
+import io.kotest.matchers.shouldBe
+import kotlinx.datetime.LocalDateTime
+import kotlinx.datetime.LocalTime
+import kotlinx.datetime.TimeZone
+import kotlinx.datetime.toKotlinLocalDate
+import kotlinx.datetime.toKotlinLocalDateTime
+import org.jetbrains.kotlinx.dataframe.DataColumn
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.api.cast
+import org.jetbrains.kotlinx.dataframe.api.columnOf
+import org.jetbrains.kotlinx.dataframe.api.convertTo
+import org.jetbrains.kotlinx.dataframe.api.convertToDouble
+import org.jetbrains.kotlinx.dataframe.api.convertToLocalDate
+import org.jetbrains.kotlinx.dataframe.api.convertToLocalDateTime
+import org.jetbrains.kotlinx.dataframe.api.convertToLocalTime
+import org.jetbrains.kotlinx.dataframe.api.parse
+import org.jetbrains.kotlinx.dataframe.api.parser
+import org.jetbrains.kotlinx.dataframe.api.plus
+import org.jetbrains.kotlinx.dataframe.api.times
+import org.jetbrains.kotlinx.dataframe.api.tryParse
+import org.jetbrains.kotlinx.dataframe.exceptions.TypeConversionException
+import org.junit.Test
+import java.math.BigDecimal
+import java.util.Locale
+import kotlin.reflect.typeOf
+
+class ParserTests {
+
+    @Test
+    fun `parse datetime with custom format`() {
+        val col by columnOf("04.02.2021 -- 19:44:32")
+        col.tryParse().type() shouldBe typeOf<String>()
+        DataFrame.parser.addDateTimePattern("dd.MM.uuuu -- HH:mm:ss")
+        val parsed = col.parse()
+        parsed.type() shouldBe typeOf<LocalDateTime>()
+        parsed.cast<LocalDateTime>()[0].year shouldBe 2021
+        DataFrame.parser.resetToDefault()
+    }
+
+    @Test(expected = IllegalStateException::class)
+    fun `parse should throw`() {
+        val col by columnOf("a", "b")
+        col.parse()
+    }
+
+    @Test(expected = TypeConversionException::class)
+    fun `converter should throw`() {
+        val col by columnOf("a", "b")
+        col.convertTo<Int>()
+    }
+
+    @Test(expected = TypeConversionException::class)
+    fun `converter for mixed column should throw`() {
+        val col by columnOf(1, "a")
+        col.convertTo<Int>()
+    }
+
+    @Test
+    fun `convert mixed column`() {
+        val col by columnOf(1.0, "1")
+        val converted = col.convertTo<Int>()
+        converted.type() shouldBe typeOf<Int>()
+        converted[0] shouldBe 1
+        converted[1] shouldBe 1
+    }
+
+    @Test
+    fun `convert BigDecimal column`() {
+        val col by columnOf(BigDecimal(1.0), BigDecimal(0.321))
+        val converted = col.convertTo<Float>()
+        converted.type() shouldBe typeOf<Float>()
+        converted[0] shouldBe 1.0f
+        converted[1] shouldBe 0.321f
+    }
+
+    @Test
+    fun `convert to Boolean`() {
+        val col by columnOf(BigDecimal(1.0), BigDecimal(0.0), 0, 1, 10L, 0.0, 0.1)
+        col.convertTo<Boolean>().shouldBe(
+            DataColumn.createValueColumn("col", listOf(true, false, false, true, true, false, true), typeOf<Boolean>()),
+        )
+    }
+
+    @Test
+    fun `convert to date and time`() {
+        val daysToStandardMillis = 24 * 60 * 60 * 1000L
+        val longCol = columnOf(1L, 60L, 3600L).times(1000L).plus(daysToStandardMillis * 366)
+        val datetimeCol = longCol.convertToLocalDateTime(TimeZone.UTC)
+
+        datetimeCol.shouldBe(
+            columnOf(
+                java.time.LocalDateTime.of(1971, 1, 2, 0, 0, 1).toKotlinLocalDateTime(),
+                java.time.LocalDateTime.of(1971, 1, 2, 0, 1, 0).toKotlinLocalDateTime(),
+                java.time.LocalDateTime.of(1971, 1, 2, 1, 0, 0).toKotlinLocalDateTime(),
+            ),
+        )
+        longCol.convertToLocalDate(TimeZone.UTC).shouldBe(
+            columnOf(
+                java.time.LocalDate.of(1971, 1, 2).toKotlinLocalDate(),
+                java.time.LocalDate.of(1971, 1, 2).toKotlinLocalDate(),
+                java.time.LocalDate.of(1971, 1, 2).toKotlinLocalDate(),
+            ),
+        )
+        longCol.convertToLocalTime(TimeZone.UTC).shouldBe(
+            columnOf(
+                LocalTime(0, 0, 1),
+                LocalTime(0, 1, 0),
+                LocalTime(1, 0, 0),
+            ),
+        )
+
+        datetimeCol.convertToLocalDate().shouldBe(
+            columnOf(
+                java.time.LocalDate.of(1971, 1, 2).toKotlinLocalDate(),
+                java.time.LocalDate.of(1971, 1, 2).toKotlinLocalDate(),
+                java.time.LocalDate.of(1971, 1, 2).toKotlinLocalDate(),
+            ),
+        )
+        datetimeCol.convertToLocalTime().shouldBe(
+            columnOf(
+                LocalTime(0, 0, 1),
+                LocalTime(0, 1, 0),
+                LocalTime(1, 0, 0),
+            ),
+        )
+    }
+
+    @Test
+    fun `converting String to Double in different locales`() {
+        val currentLocale = Locale.getDefault()
+        try {
+            // Test 45 behaviour combinations:
+
+            // 3 source columns
+            val columnDot = columnOf("12.345", "67.890")
+            val columnComma = columnOf("12,345", "67,890")
+            val columnMixed = columnOf("12.345", "67,890")
+            // *
+            // (3 locales as converting parameter + original converting + original converting to nullable)
+            val parsingLocaleNotDefined: Locale? = null
+            val parsingLocaleUsesDot: Locale = Locale.forLanguageTag("en-US")
+            val parsingLocaleUsesComma: Locale = Locale.forLanguageTag("ru-RU")
+            // *
+            // 3 system locales
+
+            Locale.setDefault(Locale.forLanguageTag("C.UTF-8"))
+
+            columnDot.convertTo<Double>().shouldBe(columnOf(12.345, 67.89))
+            columnComma.convertTo<Double>().shouldBe(columnOf(12345.0, 67890.0))
+            columnMixed.convertTo<Double>().shouldBe(columnOf(12.345, 67890.0))
+
+            columnDot.convertTo<Double?>().shouldBe(columnOf(12.345, 67.89))
+            columnComma.convertTo<Double?>().shouldBe(columnOf(12345.0, 67890.0))
+            columnMixed.convertTo<Double?>().shouldBe(columnOf(12.345, 67890.0))
+
+            columnDot.convertToDouble(parsingLocaleNotDefined).shouldBe(columnOf(12.345, 67.89))
+            columnComma.convertToDouble(parsingLocaleNotDefined).shouldBe(columnOf(12345.0, 67890.0))
+            columnMixed.convertToDouble(parsingLocaleNotDefined).shouldBe(columnOf(12.345, 67890.0))
+
+            columnDot.convertToDouble(parsingLocaleUsesDot).shouldBe(columnOf(12.345, 67.89))
+            columnComma.convertToDouble(parsingLocaleUsesDot).shouldBe(columnOf(12345.0, 67890.0))
+            columnMixed.convertToDouble(parsingLocaleUsesDot).shouldBe(columnOf(12.345, 67890.0))
+
+            shouldThrow<TypeConversionException> { columnDot.convertToDouble(parsingLocaleUsesComma) }
+            columnComma.convertToDouble(parsingLocaleUsesComma).shouldBe(columnOf(12.345, 67.89))
+            shouldThrow<TypeConversionException> { columnMixed.convertToDouble(parsingLocaleUsesComma) }
+
+            Locale.setDefault(Locale.forLanguageTag("en-US"))
+
+            columnDot.convertTo<Double>().shouldBe(columnOf(12.345, 67.89))
+            columnComma.convertTo<Double>().shouldBe(columnOf(12345.0, 67890.0))
+            columnMixed.convertTo<Double>().shouldBe(columnOf(12.345, 67890.0))
+
+            columnDot.convertTo<Double?>().shouldBe(columnOf(12.345, 67.89))
+            columnComma.convertTo<Double?>().shouldBe(columnOf(12345.0, 67890.0))
+            columnMixed.convertTo<Double?>().shouldBe(columnOf(12.345, 67890.0))
+
+            columnDot.convertToDouble(parsingLocaleNotDefined).shouldBe(columnOf(12.345, 67.89))
+            columnComma.convertToDouble(parsingLocaleNotDefined).shouldBe(columnOf(12345.0, 67890.0))
+            columnMixed.convertToDouble(parsingLocaleNotDefined).shouldBe(columnOf(12.345, 67890.0))
+
+            columnDot.convertToDouble(parsingLocaleUsesDot).shouldBe(columnOf(12.345, 67.89))
+            columnComma.convertToDouble(parsingLocaleUsesDot).shouldBe(columnOf(12345.0, 67890.0))
+            columnMixed.convertToDouble(parsingLocaleUsesDot).shouldBe(columnOf(12.345, 67890.0))
+
+            shouldThrow<TypeConversionException> { columnDot.convertToDouble(parsingLocaleUsesComma) }
+            columnComma.convertToDouble(parsingLocaleUsesComma).shouldBe(columnOf(12.345, 67.89))
+            shouldThrow<TypeConversionException> { columnMixed.convertToDouble(parsingLocaleUsesComma) }
+
+            Locale.setDefault(Locale.forLanguageTag("ru-RU"))
+
+            columnDot.convertTo<Double>().shouldBe(columnOf(12.345, 67.89))
+            columnComma.convertTo<Double>().shouldBe(columnOf(12.345, 67.89))
+            columnMixed.convertTo<Double>().shouldBe(columnOf(12.345, 67890.0))
+
+            columnDot.convertTo<Double?>().shouldBe(columnOf(12.345, 67.89))
+            columnComma.convertTo<Double?>().shouldBe(columnOf(12.345, 67.89))
+            columnMixed.convertTo<Double?>().shouldBe(columnOf(12.345, 67890.0))
+
+            columnDot.convertToDouble(parsingLocaleNotDefined).shouldBe(columnOf(12.345, 67.89))
+            columnComma.convertToDouble(parsingLocaleNotDefined).shouldBe(columnOf(12.345, 67.89))
+            columnMixed.convertToDouble(parsingLocaleNotDefined).shouldBe(columnOf(12.345, 67890.0))
+
+            columnDot.convertToDouble(parsingLocaleUsesDot).shouldBe(columnOf(12.345, 67.89))
+            columnComma.convertToDouble(parsingLocaleUsesDot).shouldBe(columnOf(12345.0, 67890.0))
+            columnMixed.convertToDouble(parsingLocaleUsesDot).shouldBe(columnOf(12.345, 67890.0))
+
+            shouldThrow<TypeConversionException> { columnDot.convertToDouble(parsingLocaleUsesComma) }
+            columnComma.convertToDouble(parsingLocaleUsesComma).shouldBe(columnOf(12.345, 67.89))
+            shouldThrow<TypeConversionException> { columnMixed.convertToDouble(parsingLocaleUsesComma) }
+        } finally {
+            Locale.setDefault(currentLocale)
+        }
+    }
+}
diff --git a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/io/PlaylistJsonTest.kt b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/io/PlaylistJsonTest.kt
new file mode 100644
index 000000000..c1df64b33
--- /dev/null
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/io/PlaylistJsonTest.kt
@@ -0,0 +1,229 @@
+package org.jetbrains.kotlinx.dataframe.io
+
+import io.kotest.matchers.shouldBe
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.DataRow
+import org.jetbrains.kotlinx.dataframe.annotations.DataSchema
+import org.jetbrains.kotlinx.dataframe.api.aggregate
+import org.jetbrains.kotlinx.dataframe.api.asGroupBy
+import org.jetbrains.kotlinx.dataframe.api.cast
+import org.jetbrains.kotlinx.dataframe.api.concat
+import org.jetbrains.kotlinx.dataframe.api.convert
+import org.jetbrains.kotlinx.dataframe.api.getColumnGroupOrNull
+import org.jetbrains.kotlinx.dataframe.api.into
+import org.jetbrains.kotlinx.dataframe.api.map
+import org.jetbrains.kotlinx.dataframe.api.minBy
+import org.jetbrains.kotlinx.dataframe.api.move
+import org.jetbrains.kotlinx.dataframe.api.remove
+import org.jetbrains.kotlinx.dataframe.api.select
+import org.jetbrains.kotlinx.dataframe.api.with
+import org.jetbrains.kotlinx.dataframe.columns.ColumnGroup
+import org.jetbrains.kotlinx.dataframe.dataTypes.IMG
+import org.junit.Test
+import kotlin.reflect.typeOf
+
+class PlaylistJsonTest {
+
+    @DataSchema(isOpen = false)
+    interface DataFrameType4 {
+        val url: String
+        val width: Int
+        val height: Int
+    }
+
+    @DataSchema(isOpen = false)
+    interface DataFrameType5 {
+        val url: String
+        val width: Int
+        val height: Int
+    }
+
+    @DataSchema(isOpen = false)
+    interface DataFrameType6 {
+        val url: String
+        val width: Int
+        val height: Int
+    }
+
+    @DataSchema(isOpen = false)
+    interface DataFrameType7 {
+        val url: String?
+        val width: Int?
+        val height: Int?
+    }
+
+    @DataSchema(isOpen = false)
+    interface DataFrameType8 {
+        val url: String?
+        val width: Int?
+        val height: Int?
+    }
+
+    @DataSchema(isOpen = false)
+    interface DataFrameType3 {
+        val default: DataRow<DataFrameType4>
+        val medium: DataRow<DataFrameType5>
+        val high: DataRow<DataFrameType6>
+        val standard: DataRow<DataFrameType7>
+        val maxres: DataRow<DataFrameType8>
+    }
+
+    @DataSchema(isOpen = false)
+    interface DataFrameType9 {
+        val kind: String
+        val videoId: String
+    }
+
+    @DataSchema(isOpen = false)
+    interface DataFrameType2 {
+        val publishedAt: String
+        val channelId: String
+        val title: String
+        val description: String
+        val thumbnails: DataRow<DataFrameType3>
+        val channelTitle: String
+        val playlistId: String
+        val position: Int
+        val resourceId: DataRow<DataFrameType9>
+    }
+
+    @DataSchema(isOpen = false)
+    interface DataFrameType1 {
+        val kind: String
+        val etag: String
+        val id: String
+        val snippet: DataRow<DataFrameType2>
+    }
+
+    @DataSchema(isOpen = false)
+    interface DataFrameType10 {
+        val totalResults: Int
+        val resultsPerPage: Int
+    }
+
+    @DataSchema
+    interface DataRecord {
+        val kind: String
+        val etag: String
+        val nextPageToken: String
+        val items: DataFrame<DataFrameType1>
+        val pageInfo: DataRow<DataFrameType10>
+    }
+
+    val path = "../data/playlistItems.json"
+    val df = DataFrame.read(path)
+    val typed = df.cast<DataRecord>()
+    val item = typed.items[0]
+
+    @Test
+    fun `deep update`() {
+        val updated = item.convert { snippet.thumbnails.default.url }.with { IMG(it) }
+        updated.snippet.thumbnails.default.url.type() shouldBe typeOf<IMG>()
+    }
+
+    @Test
+    fun `deep update group`() {
+        val updated = item.convert { snippet.thumbnails.default }.with { it.url }
+        updated.snippet.thumbnails["default"].type() shouldBe typeOf<String>()
+    }
+
+    @Test
+    fun `deep batch update`() {
+        val updated = item.convert { snippet.thumbnails.default.url and snippet.thumbnails.high.url }.with { IMG(it) }
+        updated.snippet.thumbnails.default.url.type() shouldBe typeOf<IMG>()
+        updated.snippet.thumbnails.high.url.type() shouldBe typeOf<IMG>()
+    }
+
+    @Test
+    fun `deep batch update all`() {
+        val updated = item
+            .convert { colsAtAnyDepth { it.name() == "url" } }
+            .with { (it as? String)?.let { IMG(it) } }
+        updated.snippet.thumbnails.default.url.type() shouldBe typeOf<IMG>()
+        updated.snippet.thumbnails.maxres.url.type() shouldBe typeOf<IMG?>()
+        updated.snippet.thumbnails.standard.url.type() shouldBe typeOf<IMG?>()
+        updated.snippet.thumbnails.medium.url.type() shouldBe typeOf<IMG>()
+        updated.snippet.thumbnails.high.url.type() shouldBe typeOf<IMG>()
+    }
+
+    @Test
+    fun `select group`() {
+        item.select { snippet.thumbnails.default }.columnsCount() shouldBe 1
+        item.select { snippet.thumbnails.default.allCols() }.columnsCount() shouldBe 3
+    }
+
+    @Test
+    fun `deep remove`() {
+        val item2 = item.remove {
+            snippet.thumbnails.default and
+                snippet.thumbnails.maxres and
+                snippet.channelId and
+                etag
+        }
+        item2.columnsCount() shouldBe item.columnsCount() - 1
+        item2.snippet.columnsCount() shouldBe item.snippet.columnsCount() - 1
+        item2.snippet.thumbnails.columnsCount() shouldBe item.snippet.thumbnails.columnsCount() - 2
+    }
+
+    @Test
+    fun `remove all from group`() {
+        val item2 = item.remove {
+            snippet.thumbnails.default and
+                snippet.thumbnails.maxres and
+                snippet.thumbnails.medium and
+                snippet.thumbnails.high and
+                snippet.thumbnails.standard
+        }
+        item2.snippet.columnsCount() shouldBe item.snippet.columnsCount() - 1
+        item2.snippet.getColumnGroupOrNull("thumbnails") shouldBe null
+    }
+
+    @Test
+    fun `deep move with rename`() {
+        val moved = item
+            .move { snippet.thumbnails.default }.into { snippet.path() + "movedDefault" }
+        moved.snippet.thumbnails.columnNames() shouldBe item.snippet.thumbnails
+            .remove { default }
+            .columnNames()
+        moved.snippet.columnsCount() shouldBe item.snippet.columnsCount() + 1
+        (moved.snippet["movedDefault"] as ColumnGroup<*>).columnsCount() shouldBe
+            item.snippet.thumbnails.default
+                .columnsCount()
+    }
+
+    @Test
+    fun `union`() {
+        val merged = item.concat(item)
+        merged.rowsCount() shouldBe item.rowsCount() * 2
+        val group = merged.snippet
+        group.rowsCount() shouldBe item.snippet.rowsCount() * 2
+        group.columnNames() shouldBe item.snippet.columnNames()
+    }
+
+    @Test
+    fun `select with rename`() {
+        val selected = item.select {
+            snippet.thumbnails.default.url into "default" and
+                (snippet.thumbnails.maxres.url named "maxres")
+        }
+        selected.columnNames() shouldBe listOf("default", "maxres")
+        selected["default"].toList() shouldBe item.snippet.thumbnails.default.url
+            .toList()
+        selected["maxres"].toList() shouldBe item.snippet.thumbnails.maxres.url
+            .toList()
+    }
+
+    @Test
+    fun `aggregate by column`() {
+        val res = typed.asGroupBy { items }.aggregate {
+            this into "items"
+            minBy { snippet.publishedAt }.snippet into "earliest"
+        }
+
+        res.columnsCount() shouldBe typed.columnsCount() + 1
+        res.getColumnIndex("earliest") shouldBe typed.getColumnIndex("items") + 1
+
+        val expected = typed.items.map { it.snippet.minBy { publishedAt } }.toList()
+        res["earliest"].toList() shouldBe expected
+    }
+}
diff --git a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/io/ReadTests.kt b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/io/ReadTests.kt
new file mode 100644
index 000000000..cf63deed2
--- /dev/null
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/io/ReadTests.kt
@@ -0,0 +1,110 @@
+package org.jetbrains.kotlinx.dataframe.io
+
+import io.kotest.matchers.shouldBe
+import org.jetbrains.kotlinx.dataframe.AnyFrame
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.api.all
+import org.jetbrains.kotlinx.dataframe.api.allNulls
+import org.jetbrains.kotlinx.dataframe.api.cast
+import org.jetbrains.kotlinx.dataframe.api.column
+import org.jetbrains.kotlinx.dataframe.api.getColumn
+import org.jetbrains.kotlinx.dataframe.columns.ColumnKind
+import org.jetbrains.kotlinx.dataframe.impl.columns.asAnyFrameColumn
+import org.jetbrains.kotlinx.dataframe.impl.nothingType
+import org.jetbrains.kotlinx.dataframe.ncol
+import org.jetbrains.kotlinx.dataframe.nrow
+import org.jetbrains.kotlinx.dataframe.schema.ColumnSchema
+import org.junit.Test
+import kotlin.reflect.typeOf
+
+class ReadTests {
+
+    @Test
+    fun readJsonNulls() {
+        val data =
+            """
+            [{"a":null, "b":1},{"a":null, "b":2}]
+            """.trimIndent()
+
+        val df = DataFrame.readJsonStr(data)
+        df.ncol shouldBe 2
+        df.nrow shouldBe 2
+        df["a"].hasNulls() shouldBe true
+        df["a"].allNulls() shouldBe true
+        df.all { it["a"] == null } shouldBe true
+        df["a"].type() shouldBe nothingType(nullable = true)
+        df["b"].hasNulls() shouldBe false
+    }
+
+    @Test
+    fun readFrameColumn() {
+        val data =
+            """
+            [{"a":[{"b":[]}]},{"a":[]},{"a":[{"b":[{"c":1}]}]}]
+            """.trimIndent()
+        val df = DataFrame.readJsonStr(data)
+        df.nrow shouldBe 3
+        val a = df["a"].asAnyFrameColumn()
+        a[1].nrow shouldBe 0
+        a[0].nrow shouldBe 1
+        a[2].nrow shouldBe 1
+        val schema = a.schema.value
+        schema.columns.size shouldBe 1
+        val schema2 = schema.columns["b"] as ColumnSchema.Frame
+        schema2.schema.columns.size shouldBe 1
+        schema2.schema.columns["c"]!!.kind shouldBe ColumnKind.Value
+    }
+
+    @Test
+    fun readFrameColumnEmptySlice() {
+        val data =
+            """
+            [ [], [ {"a": [{"q":2},{"q":3}] } ] ]
+            """.trimIndent()
+
+        val df = DataFrame.readJsonStr(data)
+        df.nrow shouldBe 2
+        df.ncol shouldBe 1
+        val empty = df[0][0] as AnyFrame
+        empty.nrow shouldBe 0
+        empty.ncol shouldBe 0
+    }
+
+    @Test
+    fun `read big decimal`() {
+        val data =
+            """
+            [[3452345234345, 7795.34000000], [12314123532, 7795.34000000]]
+            """.trimIndent()
+        val df = DataFrame.readJsonStr(data)
+        println(df.getColumn("array").cast<List<Number>>()[0][1].javaClass)
+    }
+
+    @Test
+    fun `array of arrays`() {
+        val data =
+            """
+            {
+                "values": [[1,2,3],[4,5,6],[7,8,9]]
+            }
+            """.trimIndent()
+        val df = DataFrame.readJsonStr(data)
+        val values by column<List<List<Int>>>()
+        df[values][0][1][1] shouldBe 5
+    }
+
+    @Test
+    fun `read json with header`() {
+        val data =
+            """
+            [[1,2,3],
+            [4,5,6]]
+            """.trimIndent()
+        val header = listOf("a", "b", "c")
+        val df = DataFrame.readJsonStr(data, header)
+        df.rowsCount() shouldBe 2
+        df.columnsCount() shouldBe 3
+        df.columnNames() shouldBe header
+        df.columnTypes() shouldBe List(3) { typeOf<Int>() }
+    }
+}
diff --git a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/io/TypeInferenceTest.kt b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/io/TypeInferenceTest.kt
new file mode 100644
index 000000000..6582ec510
--- /dev/null
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/io/TypeInferenceTest.kt
@@ -0,0 +1,19 @@
+package org.jetbrains.kotlinx.dataframe.io
+
+import io.kotest.matchers.shouldBe
+import org.jetbrains.kotlinx.dataframe.api.dataFrameOf
+import org.junit.Test
+import kotlin.reflect.typeOf
+
+class TypeInferenceTest {
+
+    open class A
+
+    private class B : A()
+
+    @Test
+    fun `private subtypes`() {
+        val df = dataFrameOf("col")(B(), B())
+        df["col"].type() shouldBe typeOf<A>()
+    }
+}
diff --git a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/io/json.kt b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/io/json.kt
new file mode 100644
index 000000000..730978aad
--- /dev/null
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/io/json.kt
@@ -0,0 +1,1121 @@
+package org.jetbrains.kotlinx.dataframe.io
+
+import io.kotest.assertions.throwables.shouldNotThrowAny
+import io.kotest.assertions.throwables.shouldThrow
+import io.kotest.matchers.collections.shouldBeIn
+import io.kotest.matchers.shouldBe
+import io.kotest.matchers.string.shouldContain
+import io.kotest.matchers.string.shouldNotContain
+import io.kotest.matchers.types.instanceOf
+import io.kotest.matchers.types.shouldBeInstanceOf
+import kotlinx.serialization.json.Json
+import kotlinx.serialization.json.JsonElement
+import kotlinx.serialization.json.boolean
+import kotlinx.serialization.json.int
+import kotlinx.serialization.json.jsonArray
+import kotlinx.serialization.json.jsonObject
+import kotlinx.serialization.json.jsonPrimitive
+import org.intellij.lang.annotations.Language
+import org.jetbrains.kotlinx.dataframe.AnyFrame
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.DataRow
+import org.jetbrains.kotlinx.dataframe.alsoDebug
+import org.jetbrains.kotlinx.dataframe.api.JsonPath
+import org.jetbrains.kotlinx.dataframe.api.allNulls
+import org.jetbrains.kotlinx.dataframe.api.columnsCount
+import org.jetbrains.kotlinx.dataframe.api.convert
+import org.jetbrains.kotlinx.dataframe.api.dataFrameOf
+import org.jetbrains.kotlinx.dataframe.api.forEach
+import org.jetbrains.kotlinx.dataframe.api.getColumnGroup
+import org.jetbrains.kotlinx.dataframe.api.getFrameColumn
+import org.jetbrains.kotlinx.dataframe.api.schema
+import org.jetbrains.kotlinx.dataframe.api.toFloat
+import org.jetbrains.kotlinx.dataframe.api.toMap
+import org.jetbrains.kotlinx.dataframe.columns.ColumnGroup
+import org.jetbrains.kotlinx.dataframe.columns.ColumnKind
+import org.jetbrains.kotlinx.dataframe.columns.FrameColumn
+import org.jetbrains.kotlinx.dataframe.columns.ValueColumn
+import org.jetbrains.kotlinx.dataframe.get
+import org.jetbrains.kotlinx.dataframe.impl.io.SERIALIZATION_VERSION
+import org.jetbrains.kotlinx.dataframe.impl.io.SerializationKeys.COLUMNS
+import org.jetbrains.kotlinx.dataframe.impl.io.SerializationKeys.DATA
+import org.jetbrains.kotlinx.dataframe.impl.io.SerializationKeys.KIND
+import org.jetbrains.kotlinx.dataframe.impl.io.SerializationKeys.KOTLIN_DATAFRAME
+import org.jetbrains.kotlinx.dataframe.impl.io.SerializationKeys.METADATA
+import org.jetbrains.kotlinx.dataframe.impl.io.SerializationKeys.NCOL
+import org.jetbrains.kotlinx.dataframe.impl.io.SerializationKeys.NROW
+import org.jetbrains.kotlinx.dataframe.impl.io.SerializationKeys.VERSION
+import org.jetbrains.kotlinx.dataframe.impl.io.readJson
+import org.jetbrains.kotlinx.dataframe.impl.nothingType
+import org.jetbrains.kotlinx.dataframe.io.JSON.TypeClashTactic.ANY_COLUMNS
+import org.jetbrains.kotlinx.dataframe.io.JSON.TypeClashTactic.ARRAY_AND_VALUE_COLUMNS
+import org.jetbrains.kotlinx.dataframe.parseJsonStr
+import org.jetbrains.kotlinx.dataframe.testJson
+import org.jetbrains.kotlinx.dataframe.type
+import org.jetbrains.kotlinx.dataframe.values
+import org.junit.Test
+import kotlin.reflect.typeOf
+
+@Suppress("ktlint:standard:argument-list-wrapping")
+class JsonTests {
+
+    @Test
+    fun `parse json array with header`() {
+        @Language("json")
+        val json =
+            """
+            [
+                [1, "a"],
+                [2, "b"],
+                [3, "c"],
+                [4, "d"],
+                [5, "e"]                
+            ]
+            """.trimIndent()
+        val df = DataFrame.readJsonStr(json, header = listOf("numbers", "letters"))
+            .alsoDebug()
+
+        df.columnsCount() shouldBe 2
+        df.rowsCount() shouldBe 5
+        df["numbers"].type() shouldBe typeOf<Int>()
+        df["letters"].type() shouldBe typeOf<String>()
+        df["numbers"].values() shouldBe listOf(1, 2, 3, 4, 5)
+        df["letters"].values() shouldBe listOf("a", "b", "c", "d", "e")
+    }
+
+    @Test
+    fun `parse json array with header Any`() {
+        @Language("json")
+        val json =
+            """
+            [
+                [1, "a"],
+                [2, "b"],
+                [3, "c"],
+                [4, "d"],
+                [5, "e"]                
+            ]
+            """.trimIndent()
+        val df = DataFrame.readJsonStr(json, header = listOf("numbers", "letters"), typeClashTactic = ANY_COLUMNS)
+            .alsoDebug()
+
+        df.columnsCount() shouldBe 2
+        df.rowsCount() shouldBe 5
+        df["numbers"].type() shouldBe typeOf<Int>()
+        df["letters"].type() shouldBe typeOf<String>()
+        df["numbers"].values() shouldBe listOf(1, 2, 3, 4, 5)
+        df["letters"].values() shouldBe listOf("a", "b", "c", "d", "e")
+    }
+
+    @Test
+    fun parseJson1() {
+        @Language("json")
+        val json =
+            """
+            [
+                {"a":1, "b":"text"},
+                {"a":2, "b":5, "c":4.5}
+            ]
+            """.trimIndent()
+        val df = DataFrame.readJsonStr(json).alsoDebug()
+        df.columnsCount() shouldBe 3
+        df.rowsCount() shouldBe 2
+        df["a"].type() shouldBe typeOf<Int>()
+        df["b"].type() shouldBe typeOf<Comparable<*>>()
+        df["c"].type() shouldBe typeOf<Double?>()
+    }
+
+    @Test
+    fun parseJson1Any() {
+        @Language("json")
+        val json =
+            """
+            [
+                {"a":1, "b":"text"},
+                {"a":2, "b":5, "c":4.5}
+            ]
+            """.trimIndent()
+        val df = DataFrame.readJsonStr(json, typeClashTactic = ANY_COLUMNS).alsoDebug()
+        df.columnsCount() shouldBe 3
+        df.rowsCount() shouldBe 2
+        df["a"].type() shouldBe typeOf<Int>()
+        df["b"].type() shouldBe typeOf<Comparable<*>>()
+        df["c"].type() shouldBe typeOf<Double?>()
+    }
+
+    @Test
+    fun parseJson2() {
+        @Language("json")
+        val json =
+            """
+            [
+                {"a":"text"},
+                {"a":{"b":2}},
+                {"a":[6,7,8]}
+            ]
+            """.trimIndent()
+        val df = DataFrame.readJsonStr(json).alsoDebug()
+        df.columnsCount() shouldBe 1
+        df.rowsCount() shouldBe 3
+        val group = df["a"] as ColumnGroup<*>
+        group.columnsCount() shouldBe 3
+        group["b"].type() shouldBe typeOf<Int?>()
+        group["value"].type() shouldBe typeOf<String?>()
+        group["array"].type() shouldBe typeOf<List<Int>>()
+    }
+
+    @Test
+    fun parseJson2Any() {
+        @Language("json")
+        val json =
+            """
+            [
+                {"a":"text"},
+                {"a":{"b":2}},
+                {"a":[6,7,8]}
+            ]
+            """.trimIndent()
+        val df = DataFrame.readJsonStr(json, typeClashTactic = ANY_COLUMNS).alsoDebug()
+        df.columnsCount() shouldBe 1
+        df.rowsCount() shouldBe 3
+        val a = df["a"] as ValueColumn<*>
+        a.type() shouldBe typeOf<Any>()
+        a[0] shouldBe "text"
+        (a[1] as DataRow<*>)["b"] shouldBe 2
+        a[2] shouldBe listOf(6, 7, 8)
+    }
+
+    @Test
+    fun parseJson3() {
+        @Language("json")
+        val json =
+            """
+            [
+                {"a":[3, 5]},
+                {},
+                {"a":[3.4, 5.6]}
+            ]
+            """.trimIndent()
+        val df = DataFrame.readJsonStr(json).alsoDebug()
+        df.columnsCount() shouldBe 1
+        df.rowsCount() shouldBe 3
+        df["a"].type() shouldBe typeOf<List<Number>>()
+        df[1]["a"] shouldBe emptyList<Int>()
+    }
+
+    @Test
+    fun parseJson3Any() {
+        @Language("json")
+        val json =
+            """
+            [
+                {"a":[3, 5]},
+                {},
+                {"a":[3.4, 5.6]}
+            ]
+            """.trimIndent()
+        val df = DataFrame.readJsonStr(json, typeClashTactic = ANY_COLUMNS).alsoDebug()
+        df.columnsCount() shouldBe 1
+        df.rowsCount() shouldBe 3
+        df["a"].type() shouldBe typeOf<List<Number>>()
+        df[1]["a"] shouldBe emptyList<Int>()
+    }
+
+    @Test
+    fun parseJson4() {
+        @Language("json")
+        val json =
+            """
+            [
+                {"a":[ {"b":2}, {"c":3} ]},
+                {"a":[ {"b":4}, {"d":5} ]}
+            ]
+            """.trimIndent()
+        val df = DataFrame.readJsonStr(json).alsoDebug()
+        df.columnsCount() shouldBe 1
+        df.rowsCount() shouldBe 2
+        val group = df["a"] as FrameColumn<*>
+        group[0].alsoDebug().let {
+            it.columnsCount() shouldBe 3
+            it.rowsCount() shouldBe 2
+            it["b"].type() shouldBe typeOf<Int?>()
+            it["c"].type() shouldBe typeOf<Int?>()
+            it["d"].type() shouldBe typeOf<Int?>()
+            it["b"].values.toList() shouldBe listOf(2, null)
+            it["c"].values.toList() shouldBe listOf(null, 3)
+            it["d"].values.toList() shouldBe listOf(null, null)
+        }
+
+        group[1].alsoDebug().let {
+            it.columnsCount() shouldBe 3
+            it.rowsCount() shouldBe 2
+            it["b"].type() shouldBe typeOf<Int?>()
+            it["c"].type() shouldBe typeOf<Int?>()
+            it["d"].type() shouldBe typeOf<Int?>()
+            it["b"].values.toList() shouldBe listOf(4, null)
+            it["c"].values.toList() shouldBe listOf(null, null)
+            it["d"].values.toList() shouldBe listOf(null, 5)
+        }
+    }
+
+    @Test
+    fun parseJson4Any() {
+        @Language("json")
+        val json =
+            """
+            [
+                {"a":[ {"b":2}, {"c":3} ]},
+                {"a":[ {"b":4}, {"d":5} ]}
+            ]
+            """.trimIndent()
+        val df = DataFrame.readJsonStr(json, typeClashTactic = ANY_COLUMNS).alsoDebug()
+        df.columnsCount() shouldBe 1
+        df.rowsCount() shouldBe 2
+        val group = df["a"] as FrameColumn<*>
+        group[0].alsoDebug().let {
+            it.columnsCount() shouldBe 3
+            it.rowsCount() shouldBe 2
+            it["b"].type() shouldBe typeOf<Int?>()
+            it["c"].type() shouldBe typeOf<Int?>()
+            it["d"].type() shouldBe typeOf<Int?>()
+            it["b"].values.toList() shouldBe listOf(2, null)
+            it["c"].values.toList() shouldBe listOf(null, 3)
+            it["d"].values.toList() shouldBe listOf(null, null)
+        }
+
+        group[1].alsoDebug().let {
+            it.columnsCount() shouldBe 3
+            it.rowsCount() shouldBe 2
+            it["b"].type() shouldBe typeOf<Int?>()
+            it["c"].type() shouldBe typeOf<Int?>()
+            it["d"].type() shouldBe typeOf<Int?>()
+            it["b"].values.toList() shouldBe listOf(4, null)
+            it["c"].values.toList() shouldBe listOf(null, null)
+            it["d"].values.toList() shouldBe listOf(null, 5)
+        }
+    }
+
+    @Test
+    fun `parse json with nested json array with mixed values`() {
+        @Language("json")
+        val json =
+            """
+            [
+                {"a":"text"},
+                {"a":{"b":2}},
+                {"a":[6, {"a": "b"}, [1, {"a" : "b"}],8]},
+                {"a":[{"a": "b"}, {"a" : "c"}, {"a" : "d"}]}
+            ]
+            """.trimIndent()
+        val df = DataFrame.readJsonStr(json).alsoDebug()
+        df.columnsCount() shouldBe 1
+        df.rowsCount() shouldBe 4
+        val group = df["a"] as ColumnGroup<*>
+        group.columnsCount() shouldBe 3
+        group["b"].type() shouldBe typeOf<Int?>()
+        group["value"].type() shouldBe typeOf<String?>()
+        group["array"].type() shouldBe typeOf<DataFrame<*>>()
+        val nestedDf = group.getFrameColumn("array")[2]
+        nestedDf["a"].type() shouldBe typeOf<String?>()
+        nestedDf["value"].type() shouldBe typeOf<Int?>()
+        nestedDf["array"].type() shouldBe typeOf<DataFrame<*>>()
+        group.getFrameColumn("array")[3].alsoDebug().let {
+            it.columnsCount() shouldBe 3
+            it.rowsCount() shouldBe 3
+            it["a"].type() shouldBe typeOf<String>()
+            it["a"].values.toList() shouldBe listOf("b", "c", "d")
+        }
+    }
+
+    @Test
+    fun `parse json with nested json array with mixed values Any`() {
+        @Language("json")
+        val json =
+            """
+            [
+                {"a":"text"},
+                {"a":{"b":2}},
+                {"a":[6, {"a": "b"}, [1, {"a" : "b"}],8]},
+                {"a":[{"a": "b"}, {"a" : "c"}, {"a" : "d"}]}
+            ]
+            """.trimIndent()
+        val df = DataFrame.readJsonStr(json, typeClashTactic = ANY_COLUMNS).alsoDebug()
+        df.columnsCount() shouldBe 1
+        df.rowsCount() shouldBe 4
+        val a = df["a"] as ValueColumn<*>
+        a.type() shouldBe typeOf<Any>()
+        a[0] shouldBe "text"
+        (a[1] as DataRow<*>).let {
+            it.columnsCount() shouldBe 1
+            it["b"] shouldBe 2
+        }
+        (a[2] as List<*>).let {
+            it[0] shouldBe 6
+            (it[1] as DataRow<*>).let {
+                it.columnsCount() shouldBe 1
+                it["a"] shouldBe "b"
+            }
+            (it[2] as List<*>).let {
+                it[0] shouldBe 1
+                (it[1] as DataRow<*>).let {
+                    it.columnsCount() shouldBe 1
+                    it["a"] shouldBe "b"
+                }
+            }
+            it[3] shouldBe 8
+        }
+        (a[3] as DataFrame<*>)
+            .alsoDebug()
+            .let {
+                it.columnsCount() shouldBe 1
+                it.rowsCount() shouldBe 3
+                it["a"].type() shouldBe typeOf<String>()
+                it["a"].values.toList() shouldBe listOf("b", "c", "d")
+            }
+    }
+
+    @Test
+    fun `write df with primitive types`() {
+        val df = dataFrameOf("colInt", "colDouble?", "colBoolean?")(
+            1, 1.0, true,
+            2, null, false,
+            3, 3.0, null,
+        ).alsoDebug("df:")
+
+        val res = DataFrame.readJsonStr(df.toJson()).alsoDebug("res:")
+        res shouldBe df
+    }
+
+    @Test
+    fun `write df with primitive types Any`() {
+        val df = dataFrameOf("colInt", "colDouble?", "colBoolean?")(
+            1, 1.0, true,
+            2, null, false,
+            3, 3.0, null,
+        ).alsoDebug("df:")
+
+        val res =
+            DataFrame.readJsonStr(df.toJson(), typeClashTactic = ANY_COLUMNS).alsoDebug("res:")
+        res shouldBe df
+    }
+
+    @Test
+    fun `NaN double serialization`() {
+        val df = dataFrameOf("v")(1.1, Double.NaN)
+        df["v"].type() shouldBe typeOf<Double>()
+        DataFrame.readJsonStr(df.toJson()) shouldBe df
+    }
+
+    @Test
+    fun `NaN double serialization Any`() {
+        val df = dataFrameOf("v")(1.1, Double.NaN)
+        df["v"].type() shouldBe typeOf<Double>()
+        DataFrame.readJsonStr(df.toJson(), typeClashTactic = ANY_COLUMNS) shouldBe df
+    }
+
+    @Test
+    fun `NaN float serialization`() {
+        val df = dataFrameOf("v")(1.1f, Float.NaN)
+        df["v"].type() shouldBe typeOf<Float>()
+        val actual = DataFrame.readJsonStr(df.toJson()).convert("v").toFloat()
+        actual shouldBe df
+    }
+
+    @Test
+    fun `NaN float serialization Any`() {
+        val df = dataFrameOf("v")(1.1f, Float.NaN)
+        df["v"].type() shouldBe typeOf<Float>()
+        val actual = DataFrame.readJsonStr(df.toJson(), typeClashTactic = ANY_COLUMNS).convert("v").toFloat()
+        actual shouldBe df
+    }
+
+    @Test
+    fun `NaN string serialization`() {
+        val df = dataFrameOf("v")("NaM", "NaN")
+        df["v"].type() shouldBe typeOf<String>()
+        DataFrame.readJsonStr(df.toJson()) shouldBe df
+    }
+
+    @Test
+    fun `NaN string serialization Any`() {
+        val df = dataFrameOf("v")("NaM", "NaN")
+        df["v"].type() shouldBe typeOf<String>()
+        DataFrame.readJsonStr(df.toJson(), typeClashTactic = ANY_COLUMNS) shouldBe df
+    }
+
+    @Test
+    fun `list serialization`() {
+        val df = dataFrameOf("a")(listOf(1, 2, 3))
+        DataFrame.readJsonStr(df.toJson()) shouldBe df
+    }
+
+    @Test
+    fun `list serialization Any`() {
+        val df = dataFrameOf("a")(listOf(1, 2, 3))
+        DataFrame.readJsonStr(df.toJson(), typeClashTactic = ANY_COLUMNS) shouldBe df
+    }
+
+    @Test
+    fun `list serialization with nulls`() {
+        val df = dataFrameOf("a")(listOf(1, 2, 3), null)
+        val text = df.toJson()
+        val df1 = DataFrame.readJsonStr(text)
+        df1["a"][1] shouldBe emptyList<Int>()
+    }
+
+    @Test
+    fun `list serialization with nulls Any`() {
+        val df = dataFrameOf("a")(listOf(1, 2, 3), null)
+        val text = df.toJson()
+        val df1 = DataFrame.readJsonStr(text, typeClashTactic = ANY_COLUMNS)
+        df1["a"][1] shouldBe emptyList<Int>()
+    }
+
+    @Test
+    fun `serialize column with name 'value'`() {
+        val df = dataFrameOf("a")(dataFrameOf("value")(1, 2, 3))
+
+        @Language("json")
+        val json = df.toJson()
+        json shouldContain "\"value\":1"
+        val df1 = DataFrame.readJsonStr(json)
+        df shouldBe df1
+    }
+
+    @Test
+    fun `literal json field named 'value'`() {
+        @Language("json")
+        val json =
+            """
+            {
+                "data": {
+                    "source": {
+                        "value": "123"
+                    }
+                }
+            }
+            """.trimIndent()
+        val df = DataFrame.readJsonStr(json)
+        df[0].getColumnGroup("data").getColumnGroup("source")["value"] shouldBe "123"
+    }
+
+    @Test
+    fun `array json field named 'value'`() {
+        @Language("json")
+        val json = """{ "value": ["123"] }"""
+
+        val df = DataFrame.readJsonStr(json).alsoDebug()
+        df[0]["value"] shouldBe listOf("123")
+    }
+
+    @Test
+    fun `record json field named 'value'`() {
+        @Language("json")
+        val json = """{ "value": { "test" : "123" } }"""
+
+        val df = DataFrame.readJsonStr(json)
+        df[0].getColumnGroup("value")["test"] shouldBe "123"
+    }
+
+    @Test
+    fun `json field named 'array'`() {
+        @Language("json")
+        val json =
+            """
+            {
+                "data": {
+                    "source": {
+                        "array": "123"
+                    }
+                }
+            }
+            """.trimIndent()
+
+        val df = DataFrame.readJsonStr(json)
+        df[0].getColumnGroup("data").getColumnGroup("source")["array"] shouldBe "123"
+    }
+
+    @Test
+    fun `array json field named 'array'`() {
+        @Language("json")
+        val json =
+            """
+            [{
+              "a": {
+                "value": "text",
+                "array": []
+              }
+            }, {
+              "a": {
+                "b": 2,
+                "array": []
+              }
+            }, {
+              "a": {
+                "array": [6, 7, 8]
+              }
+            }]
+            """.trimIndent()
+
+        val df = DataFrame.readJsonStr(json).alsoDebug()
+        val group = df.getColumnGroup("a")
+        group["array"].type() shouldBe typeOf<List<Int>>()
+        group["value"].type() shouldBe typeOf<String?>()
+        group["b"].type() shouldBe typeOf<Int?>()
+    }
+
+    @Test
+    fun `value field name clash`() {
+        @Language("json")
+        val json =
+            """
+            [
+                {"a":"text", "c": 1},
+                {"a":{"b":2,"value":1.0, "array": null, "array1":12}},
+                {"a":[6,7,8]},
+                null
+            ]
+            """.trimIndent()
+        val df = DataFrame.readJsonStr(json).alsoDebug()
+        df.columnsCount() shouldBe 2
+        df.rowsCount() shouldBe 4
+        df["c"].type() shouldBe typeOf<Int?>()
+        val group = df["a"] as ColumnGroup<*>
+        group.columnsCount() shouldBe 6
+        group["b"].type() shouldBe typeOf<Int?>()
+        group["value"].type() shouldBe typeOf<Double?>()
+        group["value1"].type() shouldBe typeOf<String?>()
+        group["array"].type() shouldBe nothingType(nullable = true)
+
+        val schema = df.schema().toString()
+        schema shouldContain "Nothing?"
+        schema shouldNotContain "Void?"
+
+        group["array1"].type() shouldBe typeOf<Int?>()
+        group["array2"].type() shouldBe typeOf<List<Int>>()
+    }
+
+    @Test
+    fun `value field (no) name clash Any`() {
+        @Language("json")
+        val json =
+            """
+            [
+                {"a":"text", "c": 1},
+                {"a":{"b":2,"value":1.0, "array": null, "array1":12}},
+                {"a":[6,7,8]},
+                null
+            ]
+            """.trimIndent()
+        val df = DataFrame.readJsonStr(json, typeClashTactic = ANY_COLUMNS).alsoDebug()
+        df.columnsCount() shouldBe 2
+        df.rowsCount() shouldBe 4
+        val c = df["c"] as ValueColumn<*>
+        c.type() shouldBe typeOf<Int?>()
+        c[0] shouldBe 1
+        c[1..3].allNulls() shouldBe true
+        val a = df["a"] as ValueColumn<*>
+        a.type() shouldBe typeOf<Any?>()
+        a[0] shouldBe "text"
+        (a[1] as DataRow<*>).let {
+            it.columnsCount() shouldBe 4
+            it["b"] shouldBe 2
+            it["value"] shouldBe 1.0
+            it["array"] shouldBe null
+            it["array1"] shouldBe 12
+        }
+        a[2] shouldBe listOf(6, 7, 8)
+        a[3] shouldBe null
+    }
+
+    @Test
+    fun `objects with null Any`() {
+        @Language("json")
+        val json =
+            """
+            [
+                {"a":{"b":1}},
+                {"a":{"b":2}},
+                {"a":{"b": null}},
+                {"a": {}},
+                {"a": null},
+                {},
+                null
+            ]
+            """.trimIndent()
+        val df = DataFrame.readJsonStr(json, typeClashTactic = ANY_COLUMNS).alsoDebug()
+        df.columnsCount() shouldBe 1
+        df.rowsCount() shouldBe 7
+        val a = df["a"] as ColumnGroup<*>
+        a.columnsCount() shouldBe 1
+        a["b"].let {
+            it.type() shouldBe typeOf<Int?>()
+            it[0] shouldBe 1
+            it[1] shouldBe 2
+            it[2..6].allNulls() shouldBe true
+        }
+    }
+
+    @Test
+    fun `primitive arrays with null Any`() {
+        @Language("json")
+        val json =
+            """
+            [
+                {"a":[1,2,3]},
+                {"a":[null]},
+                {"a":[]},
+                {"a": null},
+                {},
+                null
+            ]
+            """.trimIndent()
+        val df = DataFrame.readJsonStr(json, typeClashTactic = ANY_COLUMNS).alsoDebug()
+        df.columnsCount() shouldBe 1
+        df.rowsCount() shouldBe 6
+        val a = df["a"] as ValueColumn<*>
+        a.type shouldBe typeOf<List<Int?>>()
+        a[0] shouldBe listOf(1, 2, 3)
+        a[1] shouldBe listOf(null)
+        a[2..5].forEach {
+            it shouldBe emptyList<Int?>()
+        }
+    }
+
+    @Test
+    fun `non-primitive arrays with null Any`() {
+        @Language("json")
+        val json =
+            """
+            [
+                {"a":[null, null]},
+                {"a":[{"b" : 1},{"b":  2}]},
+                {"a":[]},
+                {"a": null},
+                {},
+                null
+            ]
+            """.trimIndent()
+        val df = DataFrame.readJsonStr(json, typeClashTactic = ANY_COLUMNS).alsoDebug()
+        df.columnsCount() shouldBe 1
+        df.rowsCount() shouldBe 6
+        val a = df["a"] as FrameColumn<*>
+        a[0].let {
+            it.columnsCount() shouldBe 1
+            it.rowsCount() shouldBe 2
+            it["b"].let {
+                it.type() shouldBe typeOf<Int?>()
+                it[0] shouldBe null
+                it[1] shouldBe null
+            }
+        }
+        a[1].let {
+            it.columnsCount() shouldBe 1
+            it.rowsCount() shouldBe 2
+            it["b"].let {
+                it.type() shouldBe typeOf<Int>()
+                it[0] shouldBe 1
+                it[1] shouldBe 2
+            }
+        }
+        a[2..5].forEach {
+            it.columnsCount() shouldBe 0
+            it.rowsCount() shouldBe 0
+        }
+    }
+
+    @Test
+    fun `Listification test Array Value`() {
+        @Language("json")
+        val json =
+            """
+            [
+                {"a":[1,2,3]},
+                {"a":null},
+                {"a":1}
+            ]
+            """.trimIndent()
+        val df = DataFrame.readJsonStr(
+            text = json,
+            typeClashTactic = ARRAY_AND_VALUE_COLUMNS,
+            keyValuePaths = listOf(JsonPath()),
+        ).alsoDebug()
+    }
+
+    @Test
+    fun `Listification test Any column`() {
+        @Language("json")
+        val json =
+            """
+            [
+                {"a":[1,2,3]},
+                {"a":null},
+                {"a":1}
+            ]
+            """.trimIndent()
+        val df = DataFrame.readJsonStr(
+            text = json,
+            typeClashTactic = ANY_COLUMNS,
+            keyValuePaths = listOf(JsonPath()),
+        ).alsoDebug()
+    }
+
+    @Test
+    fun `KeyValue property Array Value`() {
+        @Language("json")
+        val json =
+            """
+            [
+                {"a":{"b":1}},
+                {"a":{"c": 2, "d": null, "b":[1, 2, 3]}},
+                {"a":{}},
+                {"a": null},
+                {},
+                null
+            ]
+            """.trimIndent()
+
+        // before
+        val noKeyValue = DataFrame.readJsonStr(json, typeClashTactic = ARRAY_AND_VALUE_COLUMNS)
+            .alsoDebug()
+
+//        ⌌-------------------------------------------------------⌍
+//        |  | a:{b:{value:Int?, array:List<Int>}, c:Int?, d:Any?}|
+//        |--|----------------------------------------------------|
+//        | 0|         { b:{ value:1, array:[] }, c:null, d:null }|
+//        | 1|  { b:{ value:null, array:[1, 2, 3] }, c:2, d:null }|
+//        | 2|      { b:{ value:null, array:[] }, c:null, d:null }|
+//        | 3|      { b:{ value:null, array:[] }, c:null, d:null }|
+//        | 4|      { b:{ value:null, array:[] }, c:null, d:null }|
+//        | 5|      { b:{ value:null, array:[] }, c:null, d:null }|
+//        ⌎-------------------------------------------------------⌏
+        noKeyValue.columnsCount() shouldBe 1
+        noKeyValue.rowsCount() shouldBe 6
+        noKeyValue["a"].also {
+            it shouldBe instanceOf<ColumnGroup<*>>()
+            it as ColumnGroup<*>
+
+            it["b"].type() shouldBe typeOf<DataRow<*>>()
+            it["b"]["value"].type() shouldBe typeOf<Int?>()
+            it["b"]["array"].type() shouldBe typeOf<List<Int>>()
+            it["c"].type() shouldBe typeOf<Int?>()
+            it["d"].type() shouldBe nothingType(nullable = true)
+
+            it[0].let {
+                (it["b"] as DataRow<*>).toMap() shouldBe mapOf("value" to 1, "array" to emptyList<Int>())
+                it["c"] shouldBe null
+                it["d"] shouldBe null
+            }
+            it[1].let {
+                (it["b"] as DataRow<*>).toMap() shouldBe mapOf("value" to null, "array" to listOf(1, 2, 3))
+                it["c"] shouldBe 2
+                it["d"] shouldBe null
+            }
+            (it as ColumnGroup<*>)[2..5].forEach {
+                it.let {
+                    (it["b"] as DataRow<*>).toMap() shouldBe mapOf("value" to null, "array" to emptyList<Int>())
+                    it["c"] shouldBe null
+                    it["d"] shouldBe null
+                }
+            }
+        }
+
+        // $["a"] should be read as keyValue
+        val keyValuePaths = listOf(
+            JsonPath().append("a"),
+        )
+
+        // after
+        val withKeyValue =
+            DataFrame.readJsonStr(json, keyValuePaths = keyValuePaths, typeClashTactic = ARRAY_AND_VALUE_COLUMNS)
+                .alsoDebug()
+                .also {
+                    it["a"][1].let { it as AnyFrame }.alsoDebug()
+                }
+//        ⌌------------------------------⌍
+//        |  | a:[key:String, value:Any?]|
+//        |--|---------------------------|
+//        | 0| [1 x 2] { key:b, value:1 }|
+//        | 1|                    [3 x 2]| ->  { key:c, value:2 }
+//        | 2|                    [0 x 2]|     { key:d, value:null }
+//        | 3|                    [0 x 2]|     { key:b, value:[1,2,3] }
+//        | 4|                    [0 x 2]|
+//        | 5|                    [0 x 2]|
+//        ⌎------------------------------⌏
+
+        withKeyValue.columnsCount() shouldBe 1
+        withKeyValue.rowsCount() shouldBe 6
+        withKeyValue["a"].also {
+            it shouldBe instanceOf<FrameColumn<*>>()
+            it as FrameColumn<*>
+
+            it[0].let {
+                it.columnsCount() shouldBe 2
+                it.rowsCount() shouldBe 1
+                it["key"].let {
+                    it.type() shouldBe typeOf<String>()
+                    it[0] shouldBe "b"
+                }
+                it["value"].let {
+                    it.type() shouldBe typeOf<Int>() // tightened by values, but Int? is also valid of course
+                    it[0] shouldBe 1
+                }
+            }
+            it[1].let {
+                it.columnsCount() shouldBe 2
+                it.rowsCount() shouldBe 3
+                it["key"].let {
+                    it.type() shouldBe typeOf<String>()
+                    it[0] shouldBe "c"
+                    it[1] shouldBe "d"
+                }
+                it["value"].let {
+                    it.type() shouldBe typeOf<Any?>()
+                    it[0] shouldBe 2
+                    it[1] shouldBe null
+                }
+            }
+            it[2..5].forEach {
+                it.columnsCount() shouldBe 2
+                it.rowsCount() shouldBe 0
+
+                it["key"].type() shouldBe typeOf<String>()
+                it["value"].type() shouldBeIn listOf(typeOf<Any?>(), typeOf<Any>()) // no data, so Any(?) ValueColumn
+            }
+        }
+    }
+
+    @Test
+    fun `KeyValue property Any`() { // TODO needs more tests
+        @Language("json")
+        val json =
+            """
+            [
+                {"a":{"b": 1}},
+                {"a":{"c": 2, "d": null, "b":[1, 2, 3]}},
+                {"a":{}},
+                {"a": null},
+                {},
+                null
+            ]
+            """.trimIndent()
+
+        // before
+        val noKeyValue = DataFrame.readJsonStr(json, typeClashTactic = ANY_COLUMNS)
+            .alsoDebug()
+
+//        ⌌------------------------------⌍
+//        |  | a:{b:Any?, c:Int?, d:Any?}|
+//        |--|---------------------------|
+//        | 0|                    { b:1 }|
+//        | 1|{ b:[1,2,3], c:2, d: null }|
+//        | 2|                        { }|
+//        | 3|                        { }|
+//        | 4|                        { }|
+//        | 5|                        { }|
+//        ⌎------------------------------⌏
+        noKeyValue.columnsCount() shouldBe 1
+        noKeyValue.rowsCount() shouldBe 6
+        noKeyValue["a"].also {
+            it shouldBe instanceOf<ColumnGroup<*>>()
+            it as ColumnGroup<*>
+
+            it["b"].type() shouldBe typeOf<Any?>()
+            it["c"].type() shouldBe typeOf<Int?>()
+            it["d"].type() shouldBe typeOf<Any?>()
+
+            it[0].toMap() shouldBe mapOf("b" to 1, "c" to null, "d" to null)
+            it[1].toMap() shouldBe mapOf("b" to listOf(1, 2, 3), "c" to 2, "d" to null)
+            (it as ColumnGroup<*>)[2..5].forEach {
+                it.toMap() shouldBe mapOf("b" to null, "c" to null, "d" to null)
+            }
+        }
+
+        // $["a"] should be read as keyValue
+        val keyValuePaths = listOf(
+            JsonPath().append("a"),
+        )
+
+        // after
+        val withKeyValue = DataFrame.readJsonStr(
+            text = json,
+            keyValuePaths = keyValuePaths,
+            typeClashTactic = ANY_COLUMNS,
+        ).alsoDebug().also {
+            it["a"][1].let { it as AnyFrame }.alsoDebug()
+        }
+
+//        ⌌------------------------------⌍
+//        |  | a:[key:String, value:Any?]|
+//        |--|---------------------------|
+//        | 0| [1 x 2] { key:b, value:1 }|
+//        | 1|                    [3 x 2]| ->  { key:c, value:2 }
+//        | 2|                    [0 x 2]|     { key:d, value:null }
+//        | 3|                    [0 x 2]|     { key:b, value:[1,2,3] }
+//        | 4|                    [0 x 2]|
+//        | 5|                    [0 x 2]|
+//        ⌎------------------------------⌏
+        withKeyValue.columnsCount() shouldBe 1
+        withKeyValue.rowsCount() shouldBe 6
+        withKeyValue["a"].also {
+            it shouldBe instanceOf<FrameColumn<*>>()
+            it as FrameColumn<*>
+
+            it[0].let {
+                it.columnsCount() shouldBe 2
+                it.rowsCount() shouldBe 1
+                it["key"].let {
+                    it.type() shouldBe typeOf<String>()
+                    it[0] shouldBe "b"
+                }
+                it["value"].let {
+                    it.type() shouldBe typeOf<Int>() // tightened by values, but Int? is also valid of course
+                    it[0] shouldBe 1
+                }
+            }
+            it[1].let {
+                it.columnsCount() shouldBe 2
+                it.rowsCount() shouldBe 3
+                it["key"].let {
+                    it.type() shouldBe typeOf<String>()
+                    it[0] shouldBe "c"
+                    it[1] shouldBe "d"
+                }
+                it["value"].let {
+                    it.type() shouldBe typeOf<Any?>()
+                    it[0] shouldBe 2
+                    it[1] shouldBe null
+                    it[2] shouldBe listOf(1, 2, 3)
+                }
+            }
+            it[2..5].forEach {
+                it.columnsCount() shouldBe 2
+                it.rowsCount() shouldBe 0
+
+                it["key"].type() shouldBe typeOf<String>()
+                it["value"].type() shouldBeIn listOf(typeOf<Any?>(), typeOf<Any>()) // no data, so Any(?) ValueColumn
+            }
+        }
+    }
+
+    @Test
+    fun `nulls in columns should be encoded explicitly`() {
+        val df = dataFrameOf("a", "b")("1", null, "2", 12)
+        df.toJson() shouldContain "\"b\":null"
+//        df.toJson(canonical = true) shouldContain "\"b\":null"
+    }
+
+    @Test
+    fun `json with metadata flat table`() {
+        @Language("json")
+        val data =
+            """
+            [{"id":3602279,"node_id":"MDEwOlJlcG9zaXRvcnkzNjAyMjc5","name":"kotlin-web-demo","full_name":"JetBrains/kotlin-web-demo"}]
+            """.trimIndent()
+        val df = DataFrame.readJsonStr(data)
+        val jsonStr = df.toJsonWithMetadata(df.rowsCount()).trimIndent()
+        val json = parseJsonStr(jsonStr)
+
+        json[VERSION]!!.jsonPrimitive.content shouldBe SERIALIZATION_VERSION
+
+        val metadata = json[METADATA]!!.jsonObject
+        metadata[NROW]!!.jsonPrimitive.int shouldBe 1
+        metadata[NCOL]!!.jsonPrimitive.int shouldBe 4
+        val columns = metadata[COLUMNS]!!.jsonArray.map { it.jsonPrimitive.content }
+        columns shouldBe listOf("id", "node_id", "name", "full_name")
+
+        val decodedData = json[KOTLIN_DATAFRAME]!!.jsonArray
+        val decodedDf = DataFrame.readJsonStr(decodedData.toString())
+        decodedDf shouldBe df
+    }
+
+    @Test
+    fun `json with metadata column group`() {
+        @Language("json")
+        val data =
+            """
+            [{"permissions":{"admin":false,"maintain":false,"push":false,"triage":false,"pull":true}}]
+            """.trimIndent()
+        val df = DataFrame.readJsonStr(data)
+        val jsonStr = df.toJsonWithMetadata(df.rowsCount()).trimIndent()
+        val json = parseJsonStr(jsonStr)
+
+        val row = json[KOTLIN_DATAFRAME]!!.jsonArray[0].jsonObject
+
+        val permissions = row["permissions"]!!.jsonObject
+        val metadata = permissions[METADATA]!!.jsonObject
+        metadata[KIND]!!.jsonPrimitive.content shouldBe ColumnKind.Group.toString()
+
+        val decodedData = permissions[DATA]!!.jsonObject
+
+        decodedData["admin"]!!.jsonPrimitive.boolean shouldBe false
+        decodedData["maintain"]!!.jsonPrimitive.boolean shouldBe false
+        decodedData["push"]!!.jsonPrimitive.boolean shouldBe false
+        decodedData["triage"]!!.jsonPrimitive.boolean shouldBe false
+        decodedData["pull"]!!.jsonPrimitive.boolean shouldBe true
+    }
+
+    @Test
+    fun `json with metadata frame column`() {
+        val df = DataFrame.readJson(testJson("repositories"))
+        val jsonStr = df.toJsonWithMetadata(df.rowsCount()).trimIndent()
+        val json = parseJsonStr(jsonStr)
+        val row = json[KOTLIN_DATAFRAME]!!.jsonArray[0].jsonObject
+
+        val contributors = row["contributors"]!!.jsonObject
+
+        val metadata = contributors[METADATA]!!.jsonObject
+        metadata[KIND]!!.jsonPrimitive.content shouldBe ColumnKind.Frame.toString()
+        metadata[NCOL]!!.jsonPrimitive.int shouldBe 8
+        metadata[NROW]!!.jsonPrimitive.int shouldBe 29
+
+        val decodedData = contributors[DATA]!!.jsonArray
+        decodedData.size shouldBe 29
+
+        val decodedDf = DataFrame.readJsonStr(decodedData.toString())
+        decodedDf shouldBe df[0]["contributors"] as AnyFrame
+    }
+
+    @Test
+    fun `json with metadata test row limit`() {
+        val df = DataFrame.readJson(testJson("repositories"))
+        val nestedFrameRowLimit = 20
+        val jsonStr = df.toJsonWithMetadata(df.rowsCount(), nestedFrameRowLimit).trimIndent()
+        val json = parseJsonStr(jsonStr)
+        val row = json[KOTLIN_DATAFRAME]!!.jsonArray[0].jsonObject
+
+        val contributors = row["contributors"]!!.jsonObject
+
+        val metadata = contributors[METADATA]!!.jsonObject
+        metadata[KIND]!!.jsonPrimitive.content shouldBe ColumnKind.Frame.toString()
+        metadata[NCOL]!!.jsonPrimitive.int shouldBe 8
+        metadata[NROW]!!.jsonPrimitive.int shouldBe 29
+
+        val decodedData = contributors[DATA]!!.jsonArray
+        decodedData.size shouldBe nestedFrameRowLimit
+    }
+
+    @Test
+    fun `serialize column with list of objects`() {
+        val df = dataFrameOf("col")(Regex(".+").findAll("abc").toList())
+        val json = shouldNotThrowAny { df.toJson() }
+        val list = DataFrame.readJsonStr(json)["col"][0].shouldBeInstanceOf<List<*>>()
+        list[0].shouldBeInstanceOf<String>()
+    }
+
+    @Test
+    fun `serialize column with list of primitives`() {
+        val df = dataFrameOf("col")(listOf(1, 2, 3))
+        val json = df.toJson()
+        DataFrame.readJsonStr(json) shouldBe df
+    }
+
+    @Test
+    fun `parse invalid literal`() {
+        // https://github.com/Kotlin/kotlinx.serialization/issues/2511
+        val json = Json.decodeFromString<JsonElement>("""[jetbrains, jetbrains-youtrack, youtrack, youtrack-api]""")
+        shouldThrow<IllegalStateException> {
+            readJson(json, emptyList())
+        }
+    }
+}
diff --git a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/jupyter/CodeGenerationTests.kt b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/jupyter/CodeGenerationTests.kt
new file mode 100644
index 000000000..a7f1d28e1
--- /dev/null
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/jupyter/CodeGenerationTests.kt
@@ -0,0 +1,64 @@
+package org.jetbrains.kotlinx.dataframe.jupyter
+
+import org.intellij.lang.annotations.Language
+import org.jetbrains.kotlinx.jupyter.api.Code
+import org.junit.Test
+
+class CodeGenerationTests : DataFrameJupyterTest() {
+
+    private fun Code.checkCompilation() {
+        lines().forEach {
+            execRendered(it)
+        }
+    }
+
+    @Test
+    fun `Type erased dataframe`() {
+        @Language("kts")
+        val a = """
+            fun create(): Any? = dataFrameOf("a")(1)
+            val df = create()
+            df.a
+        """.checkCompilation()
+    }
+
+    @Test
+    fun `nullable dataframe`() {
+        @Language("kts")
+        val a = """
+            fun create(): AnyFrame? = dataFrameOf("a")(1)
+            val df = create()
+            df.a
+        """.checkCompilation()
+    }
+
+    @Test
+    fun `nullable columnGroup`() {
+        @Language("kts")
+        val a = """
+            fun create(): AnyCol? = dataFrameOf("a")(1).asColumnGroup().asDataColumn()
+            val col = create()
+            col.a
+        """.checkCompilation()
+    }
+
+    @Test
+    fun `nullable dataRow`() {
+        @Language("kts")
+        val a = """
+            fun create(): AnyRow? = dataFrameOf("a")(1).single()
+            val row = create()
+            row.a
+        """.checkCompilation()
+    }
+
+    @Test
+    fun `interface without body compiled correctly`() {
+        """
+            val a = dataFrameOf("a")(1, 2, 3)
+            val b = dataFrameOf("b")(1, 2, 3)
+            val ab = dataFrameOf("a", "b")(1, 2)
+            ab.a
+        """.checkCompilation()
+    }
+}
diff --git a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/jupyter/DataFrameJupyterTest.kt b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/jupyter/DataFrameJupyterTest.kt
new file mode 100644
index 000000000..ba8d60b11
--- /dev/null
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/jupyter/DataFrameJupyterTest.kt
@@ -0,0 +1,50 @@
+package org.jetbrains.kotlinx.dataframe.jupyter
+
+import org.jetbrains.jupyter.parser.notebook.Cell
+import org.jetbrains.kotlinx.jupyter.testkit.JupyterReplTestCase
+import org.jetbrains.kotlinx.jupyter.testkit.ReplProvider
+
+abstract class DataFrameJupyterTest : JupyterReplTestCase(ReplProvider.forLibrariesTesting(listOf("dataframe")))
+
+fun interface CodeReplacer {
+    fun replace(code: String): String
+
+    companion object {
+        val DEFAULT = CodeReplacer { it }
+
+        fun byMap(replacements: Map<String, String>) =
+            CodeReplacer { code ->
+                replacements.entries.fold(code) { acc, (key, replacement) ->
+                    acc.replace(key, replacement)
+                }
+            }
+
+        fun byMap(vararg replacements: Pair<String, String>): CodeReplacer = byMap(mapOf(*replacements))
+    }
+}
+
+fun interface CellClause {
+    fun isAccepted(cell: Cell): Boolean
+
+    companion object {
+        val IS_CODE = CellClause { it.type == Cell.Type.CODE }
+    }
+}
+
+infix fun CellClause.and(other: CellClause): CellClause =
+    CellClause { cell ->
+        // Prevent lazy evaluation
+        val acceptedThis = this.isAccepted(cell)
+        val acceptedOther = other.isAccepted(cell)
+        acceptedThis && acceptedOther
+    }
+
+fun CellClause.Companion.stopAfter(breakClause: CellClause) =
+    object : CellClause {
+        var clauseTriggered: Boolean = false
+
+        override fun isAccepted(cell: Cell): Boolean {
+            clauseTriggered = clauseTriggered || breakClause.isAccepted(cell)
+            return !clauseTriggered
+        }
+    }
diff --git a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/jupyter/JupyterCodegenTests.kt b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/jupyter/JupyterCodegenTests.kt
new file mode 100644
index 000000000..8c201e9d7
--- /dev/null
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/jupyter/JupyterCodegenTests.kt
@@ -0,0 +1,358 @@
+package org.jetbrains.kotlinx.dataframe.jupyter
+
+import io.kotest.assertions.throwables.shouldNotThrowAny
+import io.kotest.matchers.should
+import io.kotest.matchers.shouldBe
+import io.kotest.matchers.types.shouldBeInstanceOf
+import org.intellij.lang.annotations.Language
+import org.jetbrains.kotlinx.dataframe.AnyFrame
+import org.jetbrains.kotlinx.dataframe.api.isNotEmpty
+import org.jetbrains.kotlinx.dataframe.columns.ValueColumn
+import org.jetbrains.kotlinx.dataframe.type
+import org.jetbrains.kotlinx.jupyter.api.MimeTypedResult
+import org.jetbrains.kotlinx.jupyter.testkit.JupyterReplTestCase
+import org.junit.Test
+import kotlin.reflect.typeOf
+
+class JupyterCodegenTests : JupyterReplTestCase() {
+
+    @Test
+    fun `codegen adding column with generic type function`() {
+        @Language("kts")
+        val res1 = execRendered(
+            """
+            fun <T> AnyFrame.addValue(value: T) = add("value") { listOf(value) }
+            val df = dataFrameOf("a")(1).addValue(2)
+            """.trimIndent(),
+        )
+        res1 shouldBe Unit
+
+        @Language("kts")
+        val res2 = execRaw("df") as AnyFrame
+
+        res2["value"].type shouldBe typeOf<List<Any?>>()
+    }
+
+    @Test
+    fun `Don't inherit from data class`() {
+        @Language("kts")
+        val res1 = execRendered(
+            """
+            @DataSchema
+            data class A(val a: Int)
+            """.trimIndent(),
+        )
+
+        @Language("kts")
+        val res2 = execRaw(
+            """
+            val df = dataFrameOf("a", "b")(1, 2)
+            df
+            """.trimIndent(),
+        )
+
+        (res2 as AnyFrame).should { it.isNotEmpty() }
+    }
+
+    @Test
+    fun `Don't inherit from non open class`() {
+        @Language("kts")
+        val res1 = execRendered(
+            """
+            @DataSchema
+            class A(val a: Int)
+            """.trimIndent(),
+        )
+
+        @Language("kts")
+        val res2 = execRaw(
+            """
+            val df = dataFrameOf("a", "b")(1, 2)
+            df
+            """.trimIndent(),
+        )
+
+        (res2 as AnyFrame).should { it.isNotEmpty() }
+    }
+
+    @Test
+    fun `Don't inherit from open class`() {
+        @Language("kts")
+        val res1 = execRendered(
+            """
+            @DataSchema
+            open class A(val a: Int)
+            """.trimIndent(),
+        )
+
+        @Language("kts")
+        val res2 = execRaw(
+            """
+            val df = dataFrameOf("a", "b")(1, 2)
+            df
+            """.trimIndent(),
+        )
+
+        (res2 as AnyFrame).should { it.isNotEmpty() }
+    }
+
+    @Test
+    fun `Do inherit from open interface`() {
+        @Language("kts")
+        val res1 = execRendered(
+            """
+            @DataSchema
+            interface A { val a: Int }
+            """.trimIndent(),
+        )
+
+        @Language("kts")
+        val res2 = execRaw(
+            """
+            val df = dataFrameOf("a", "b")(1, 2)
+            df
+            """.trimIndent(),
+        )
+
+        (res2 as AnyFrame).should { it.isNotEmpty() }
+    }
+
+    @Test
+    fun `codegen for enumerated frames`() {
+        @Language("kts")
+        val res1 = execRendered(
+            """
+            val names = (0..2).map { it.toString() }
+            val df = dataFrameOf(names)(1, 2, 3)
+            """.trimIndent(),
+        )
+        res1 shouldBe Unit
+
+        @Language("kts")
+        val res2 = execRaw("df.`1`")
+        res2.shouldBeInstanceOf<ValueColumn<*>>()
+    }
+
+    @Test
+    fun `codegen for complex column names`() {
+        @Language("kts")
+        val res1 = execRendered(
+            """
+            val df = DataFrame.readDelimStr("[a], (b), {c}\n1, 2, 3")
+            df
+            """.trimIndent(),
+        )
+        res1.shouldBeInstanceOf<MimeTypedResult>()
+
+        @Language("kts")
+        val res2 = execRendered(
+            """listOf(df.`{a}`[0], df.`(b)`[0], df.`{c}`[0])""",
+        )
+        res2 shouldBe listOf(1, 2, 3)
+    }
+
+    @Test
+    fun `codegen for '$' that is interpolator in kotlin string literals`() {
+        @Language("kts")
+        val res1 = execRendered(
+            """
+            val df = DataFrame.readDelimStr("\${'$'}id\n1")
+            df
+            """.trimIndent(),
+        )
+        res1.shouldBeInstanceOf<MimeTypedResult>()
+
+        @Language("kts")
+        val res2 = execRendered(
+            "listOf(df.`\$id`[0])",
+        )
+        res2 shouldBe listOf(1)
+    }
+
+    @Test
+    fun `codegen for backtick that is forbidden in kotlin identifiers`() {
+        @Language("kts")
+        val res1 = execRendered(
+            """
+            val df = DataFrame.readDelimStr("Day`s\n1")
+            df
+            """.trimIndent(),
+        )
+        res1.shouldBeInstanceOf<MimeTypedResult>()
+        println(res1.entries.joinToString())
+
+        @Language("kts")
+        val res2 = execRendered(
+            "listOf(df.`Day's`[0])",
+        )
+        res2 shouldBe listOf(1)
+    }
+
+    @Test
+    fun `codegen for chars that is forbidden in JVM identifiers`() {
+        val forbiddenChar = ";"
+
+        @Language("kts")
+        val res1 = execRendered(
+            """
+            val df = DataFrame.readDelimStr("Test$forbiddenChar\n1")
+            df
+            """.trimIndent(),
+        )
+        res1.shouldBeInstanceOf<MimeTypedResult>()
+        println(res1.entries.joinToString())
+
+        @Language("kts")
+        val res2 = execRendered(
+            "listOf(df.`Test `[0])",
+        )
+        res2 shouldBe listOf(1)
+    }
+
+    @Test
+    fun `codegen for chars that is forbidden in JVM identifiers 1`() {
+        val forbiddenChar = "\\\\"
+
+        @Language("kts")
+        val res1 = execRendered(
+            """
+            val df = DataFrame.readDelimStr("Test$forbiddenChar\n1")
+            df
+            """.trimIndent(),
+        )
+        res1.shouldBeInstanceOf<MimeTypedResult>()
+        println(res1.entries.joinToString())
+
+        @Language("kts")
+        val res2 = execRendered(
+            "listOf(df.`Test `[0])",
+        )
+        res2 shouldBe listOf(1)
+    }
+
+    @Test
+    fun `generic interface`() {
+        @Language("kts")
+        val res1 = execRendered(
+            """
+            @DataSchema
+            interface Generic<T> {
+                val field: T
+            }
+            """.trimIndent(),
+        )
+        res1.shouldBeInstanceOf<Unit>()
+
+        @Language("kts")
+        val res2 = execRendered(
+            """
+            val <T> ColumnsContainer<Generic<T>>.test1: DataColumn<T> get() = field
+            val <T> DataRow<Generic<T>>.test2: T get() = field
+            """.trimIndent(),
+        )
+        res2.shouldBeInstanceOf<Unit>()
+    }
+
+    @Test
+    fun `generic interface with upper bound`() {
+        @Language("kts")
+        val res1 = execRendered(
+            """
+            @DataSchema
+            interface Generic <T : String> {
+                val field: T
+            }
+            """.trimIndent(),
+        )
+        res1.shouldBeInstanceOf<Unit>()
+
+        @Language("kts")
+        val res2 = execRendered(
+            """
+            val <T : String> ColumnsContainer<Generic<T>>.test1: DataColumn<T> get() = field
+            val <T : String> DataRow<Generic<T>>.test2: T get() = field
+            """.trimIndent(),
+        )
+        res2.shouldBeInstanceOf<Unit>()
+    }
+
+    @Test
+    fun `generic interface with variance and user type in type parameters`() {
+        @Language("kts")
+        val res1 = execRendered(
+            """
+            interface UpperBound
+
+            @DataSchema(isOpen = false)
+            interface Generic <out T : UpperBound> {
+                val field: T
+            }
+            """.trimIndent(),
+        )
+        res1.shouldBeInstanceOf<Unit>()
+
+        @Language("kts")
+        val res2 = execRendered(
+            """
+            val <T : UpperBound> ColumnsContainer<Generic<T>>.test1: DataColumn<T> get() = field
+            val <T : UpperBound> DataRow<Generic<T>>.test2: T get() = field
+            """.trimIndent(),
+        )
+        res2.shouldBeInstanceOf<Unit>()
+    }
+
+    @Test
+    fun `type converter does not conflict with other type converters`() {
+        @Language("kts")
+        val anotherTypeConverter =
+            """
+            notebook.fieldsHandlersProcessor.register(
+                FieldHandlerFactory.createUpdateHandler<ByteArray>(TypeDetection.RUNTIME) { _, prop ->
+                     execute(prop.name + ".toList()").name
+                },
+                ProcessingPriority.LOW
+            )
+            """.trimIndent()
+        execEx(anotherTypeConverter)
+        execEx("val x = ByteArray(1)")
+        val res1 = execRaw("x")
+        res1.shouldBeInstanceOf<List<*>>()
+    }
+
+    @Test
+    fun `generate a new marker when dataframe marker is not a data schema so that columns are accessible with extensions`() {
+        @Language("kts")
+        val a = execRendered(
+            """
+            enum class State {
+                Idle, Productive, Maintenance
+            }
+
+            class Event(val toolId: String, val state: State, val timestamp: Long)
+
+            val tool1 = "tool_1"
+            val tool2 = "tool_2"
+            val tool3 = "tool_3"
+            val events = listOf(
+                Event(tool1, State.Idle, 0),
+                Event(tool1, State.Productive, 5),
+                Event(tool2, State.Idle, 0),
+                Event(tool2, State.Maintenance, 10),
+                Event(tool2, State.Idle, 20),
+                Event(tool3, State.Idle, 0),
+                Event(tool3, State.Productive, 25),
+            ).toDataFrame()
+            """.trimIndent(),
+        )
+        shouldNotThrowAny {
+            @Language("kts")
+            val b = execRendered(
+                """
+                events.toolId
+                events.state
+                events.timestamp
+                """.trimIndent(),
+            )
+        }
+    }
+}
diff --git a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/jupyter/RenderingTests.kt b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/jupyter/RenderingTests.kt
new file mode 100644
index 000000000..371746990
--- /dev/null
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/jupyter/RenderingTests.kt
@@ -0,0 +1,619 @@
+package org.jetbrains.kotlinx.dataframe.jupyter
+
+import io.kotest.assertions.throwables.shouldNotThrow
+import io.kotest.matchers.comparables.shouldBeGreaterThan
+import io.kotest.matchers.comparables.shouldBeLessThan
+import io.kotest.matchers.shouldBe
+import io.kotest.matchers.string.shouldContain
+import io.kotest.matchers.string.shouldNotContain
+import kotlinx.serialization.json.Json
+import kotlinx.serialization.json.JsonArray
+import kotlinx.serialization.json.JsonObject
+import kotlinx.serialization.json.int
+import kotlinx.serialization.json.jsonArray
+import kotlinx.serialization.json.jsonObject
+import kotlinx.serialization.json.jsonPrimitive
+import org.intellij.lang.annotations.Language
+import org.jetbrains.kotlinx.dataframe.impl.io.SerializationKeys.DATA
+import org.jetbrains.kotlinx.dataframe.impl.io.SerializationKeys.KOTLIN_DATAFRAME
+import org.jetbrains.kotlinx.dataframe.impl.io.SerializationKeys.METADATA
+import org.jetbrains.kotlinx.jupyter.api.MimeTypedResult
+import org.jetbrains.kotlinx.jupyter.testkit.JupyterReplTestCase
+import org.junit.BeforeClass
+import org.junit.Test
+
+class RenderingTests : JupyterReplTestCase() {
+    @Test
+    fun `dataframe is rendered to html`() {
+        @Language("kts")
+        val html = execHtml(
+            """
+            val name by column<String>()
+            val height by column<Int>()
+            val df = dataFrameOf(name, height)(
+                "Bill", 135,
+                "Charlie", 160
+            )
+            df
+            """.trimIndent(),
+        )
+        html shouldContain "Bill"
+
+        @Language("kts")
+        val useRes = execRendered(
+            """
+            USE {
+                render<Int> { (it * 2).toString() }
+            }
+            """.trimIndent(),
+        )
+        useRes shouldBe Unit
+
+        val html2 = execHtml("df")
+        html2 shouldContain (135 * 2).toString()
+        html2 shouldContain (160 * 2).toString()
+    }
+
+    @Test
+    fun `rendering options`() {
+        @Language("kts")
+        val html1 = execHtml(
+            """
+            data class Person(val age: Int, val name: String)
+            val df = (1..70).map { Person(it, "A".repeat(it)) }.toDataFrame()
+            df
+            """.trimIndent(),
+        )
+        html1 shouldContain "showing only top 20 of 70 rows"
+
+        @Language("kts")
+        val html2 = execHtml(
+            """
+            dataFrameConfig.display.rowsLimit = 50
+            df
+            """.trimIndent(),
+        )
+        html2 shouldContain "showing only top 50 of 70 rows"
+    }
+
+    @Test
+    fun `dark color scheme`() {
+        fun execSimpleDf() = execHtml("""dataFrameOf("a", "b")(1, 2, 3, 4)""")
+
+        val htmlLight = execSimpleDf()
+        val r1 = execRendered("notebook.changeColorScheme(ColorScheme.DARK); 1")
+        val htmlDark = execSimpleDf()
+
+        r1 shouldBe 1
+        val darkClassAttribute = """theme='dark'"""
+        htmlLight shouldNotContain darkClassAttribute
+        htmlDark shouldContain darkClassAttribute
+    }
+
+    @Test
+    fun `test kotlin notebook plugin utils rows subset`() {
+        val json = executeScriptAndParseDataframeResult(
+            """
+            data class Row(val id: Int)
+            val df = (1..100).map { Row(it) }.toDataFrame()
+            KotlinNotebookPluginUtils.getRowsSubsetForRendering(df, 20 , 50)
+            """.trimIndent(),
+        )
+
+        assertDataFrameDimensions(json, 30, 1)
+
+        val rows = json[KOTLIN_DATAFRAME]!!.jsonArray
+        rows.getObj(0)["id"]?.jsonPrimitive?.int shouldBe 21
+        rows.getObj(rows.lastIndex)["id"]?.jsonPrimitive?.int shouldBe 50
+    }
+
+    /**
+     * Executes the given `script` and parses the resulting DataFrame as a `JsonObject`.
+     *
+     * @param script the script to be executed
+     * @return the parsed DataFrame result as a `JsonObject`
+     */
+    private fun executeScriptAndParseDataframeResult(
+        @Language("kts") script: String,
+    ): JsonObject {
+        val result = execRendered<MimeTypedResult>(script)
+        return parseDataframeJson(result)
+    }
+
+    private fun assertDataFrameDimensions(json: JsonObject, expectedRows: Int, expectedColumns: Int) {
+        json[METADATA]!!.jsonObject["nrow"]!!.jsonPrimitive.int shouldBe expectedRows
+        json[METADATA]!!.jsonObject["ncol"]!!.jsonPrimitive.int shouldBe expectedColumns
+    }
+
+    private fun parseDataframeJson(result: MimeTypedResult): JsonObject =
+        Json.decodeFromString<JsonObject>(result["application/kotlindataframe+json"]!!)
+
+    private fun JsonArray.getObj(index: Int) = this[index].jsonObject
+
+    @Test
+    fun `test kotlin notebook plugin utils sort by one column asc`() {
+        val json = executeScriptAndParseDataframeResult(
+            """
+            data class CustomRow(val id: Int, val category: String)
+            val df = (1..100).map { CustomRow(it, if (it % 2 == 0) "even" else "odd") }.toDataFrame()
+            KotlinNotebookPluginUtils.sortByColumns(df, listOf(listOf("id")), listOf(false))
+            """.trimIndent(),
+        )
+
+        assertDataFrameDimensions(json, 100, 2)
+        assertSortedById(json, false)
+    }
+
+    @Suppress("UNCHECKED_CAST")
+    private fun assertSortedById(json: JsonObject, desc: Boolean) {
+        val rows = json[KOTLIN_DATAFRAME]!!.jsonArray as List<JsonObject>
+        var previousId = if (desc) 101 else 0
+        rows.forEach { row: JsonObject ->
+            val currentId = row["id"]!!.jsonPrimitive.int
+            if (desc) currentId shouldBeLessThan previousId else currentId shouldBeGreaterThan previousId
+            previousId = currentId
+        }
+    }
+
+    @Test
+    fun `test kotlin notebook plugin utils sort by one column desc`() {
+        val json = executeScriptAndParseDataframeResult(
+            """
+            data class CustomRow(val id: Int, val category: String)
+            val df = (1..100).map { CustomRow(it, if (it % 2 == 0) "even" else "odd") }.toDataFrame()
+            KotlinNotebookPluginUtils.sortByColumns(df, listOf(listOf("id")), listOf(true))
+            """.trimIndent(),
+        )
+
+        assertDataFrameDimensions(json, 100, 2)
+        assertSortedById(json, true)
+    }
+
+    @Suppress("UNCHECKED_CAST")
+    @Test
+    fun `test kotlin notebook plugin utils sort by multiple columns`() {
+        val json = executeScriptAndParseDataframeResult(
+            """
+            data class CustomRow(val id: Int, val category: String)
+            val df = (1..100).map { CustomRow(it, if (it % 2 == 0) "even" else "odd") }.toDataFrame()
+            KotlinNotebookPluginUtils.getRowsSubsetForRendering(
+                KotlinNotebookPluginUtils.sortByColumns(df, listOf(listOf("category"), listOf("id")), listOf(true, false)),
+                0, 100
+            )
+            """.trimIndent(),
+        )
+
+        assertDataFrameDimensions(json, 100, 2)
+
+        val rows = json[KOTLIN_DATAFRAME]!!.jsonArray as List<JsonObject>
+        assertSortedByCategory(rows)
+        assertSortedById(rows)
+    }
+
+    private fun assertSortedByCategory(rows: List<JsonObject>) {
+        rows.forEachIndexed { i, row ->
+            val currentCategory = row["category"]!!.jsonPrimitive.content
+            if (i < 50) {
+                currentCategory shouldBe "odd"
+            } else {
+                currentCategory shouldBe "even"
+            }
+        }
+    }
+
+    private fun assertSortedById(rows: List<JsonObject>) {
+        var previousCategory = "odd"
+        var previousId = 0
+        for (row in rows) {
+            val currentCategory = row["category"]!!.jsonPrimitive.content
+            val currentId = row["id"]!!.jsonPrimitive.int
+
+            if (previousCategory == "odd" && currentCategory == "even") {
+                previousId shouldBeGreaterThan currentId
+            } else if (previousCategory == currentCategory) {
+                previousId shouldBeLessThan currentId
+            }
+
+            previousCategory = currentCategory
+            previousId = currentId
+        }
+    }
+
+    @Test
+    fun `json metadata contains schema metadata`() {
+        val json = executeScriptAndParseDataframeResult(
+            """
+            val col1 by columnOf("a", "b", "c")
+            val col2 by columnOf(1, 2, 3)
+            val col3 by columnOf("Foo", "Bar", null)
+            val df2 = dataFrameOf(Pair("header", listOf("A", "B", "C")))
+            val col4 by columnOf(df2, df2, df2)
+            var df = dataFrameOf(col1, col2, col3, col4)
+            df.group(col1, col2).into("group")            
+            """.trimIndent(),
+        )
+        val expectedOutput =
+            """
+            {
+              "${'$'}version": "2.1.1",
+              "metadata": {
+                "columns": ["group", "col3", "col4"],
+                "types": [{
+                  "kind": "ColumnGroup"
+                }, {
+                  "kind": "ValueColumn",
+                  "type": "kotlin.String?"
+                }, {
+                  "kind": "FrameColumn"
+                }],
+                "nrow": 3,
+                "ncol": 3
+              },
+              "kotlin_dataframe": [{
+                "group": {
+                  "data": {
+                    "col1": "a",
+                    "col2": 1
+                  },
+                  "metadata": {
+                    "kind": "ColumnGroup",
+                    "columns": ["col1", "col2"],
+                    "types": [{
+                      "kind": "ValueColumn",
+                      "type": "kotlin.String"
+                    }, {
+                      "kind": "ValueColumn",
+                      "type": "kotlin.Int"
+                    }]
+                  }
+                },
+                "col3": "Foo",
+                "col4": {
+                  "data": [{
+                    "header": "A"
+                  }, {
+                    "header": "B"
+                  }, {
+                    "header": "C"
+                  }],
+                  "metadata": {
+                    "kind": "FrameColumn",
+                    "columns": ["header"],
+                    "types": [{
+                      "kind": "ValueColumn",
+                      "type": "kotlin.String"
+                    }],
+                    "ncol": 1,
+                    "nrow": 3
+                  }
+                }
+              }, {
+                "group": {
+                  "data": {
+                    "col1": "b",
+                    "col2": 2
+                  },
+                  "metadata": {
+                    "kind": "ColumnGroup",
+                    "columns": ["col1", "col2"],
+                    "types": [{
+                      "kind": "ValueColumn",
+                      "type": "kotlin.String"
+                    }, {
+                      "kind": "ValueColumn",
+                      "type": "kotlin.Int"
+                    }]
+                  }
+                },
+                "col3": "Bar",
+                "col4": {
+                  "data": [{
+                    "header": "A"
+                  }, {
+                    "header": "B"
+                  }, {
+                    "header": "C"
+                  }],
+                  "metadata": {
+                    "kind": "FrameColumn",
+                    "columns": ["header"],
+                    "types": [{
+                      "kind": "ValueColumn",
+                      "type": "kotlin.String"
+                    }],
+                    "ncol": 1,
+                    "nrow": 3
+                  }
+                }
+              }, {
+                "group": {
+                  "data": {
+                    "col1": "c",
+                    "col2": 3
+                  },
+                  "metadata": {
+                    "kind": "ColumnGroup",
+                    "columns": ["col1", "col2"],
+                    "types": [{
+                      "kind": "ValueColumn",
+                      "type": "kotlin.String"
+                    }, {
+                      "kind": "ValueColumn",
+                      "type": "kotlin.Int"
+                    }]
+                  }
+                },
+                "col3": null,
+                "col4": {
+                  "data": [{
+                    "header": "A"
+                  }, {
+                    "header": "B"
+                  }, {
+                    "header": "C"
+                  }],
+                  "metadata": {
+                    "kind": "FrameColumn",
+                    "columns": ["header"],
+                    "types": [{
+                      "kind": "ValueColumn",
+                      "type": "kotlin.String"
+                    }],
+                    "ncol": 1,
+                    "nrow": 3
+                  }
+                }
+              }]
+            }
+            """.trimIndent()
+        json shouldBe Json.parseToJsonElement(expectedOutput)
+    }
+
+    @Test
+    fun `test kotlin dataframe conversion groupby`() {
+        val json = executeScriptAndParseDataframeResult(
+            """
+            data class Row(val id: Int, val group: Int)
+            val df = (1..20).map { Row(it, if (it <= 10) 1 else 2) }.toDataFrame()
+            KotlinNotebookPluginUtils.convertToDataFrame(df.groupBy("group"))
+            """.trimIndent(),
+        )
+
+        assertDataFrameDimensions(json, 2, 2)
+
+        val rows = json[KOTLIN_DATAFRAME]!!.jsonArray
+        rows.getObj(0)["group1"]!!
+            .jsonObject[DATA]!!
+            .jsonArray.size shouldBe 10
+        rows.getObj(1)["group1"]!!
+            .jsonObject[DATA]!!
+            .jsonArray.size shouldBe 10
+    }
+
+    // Regression KTNB-424
+    @Test
+    fun `test kotlin dataframe conversion ReducedGroupBy`() {
+        shouldNotThrow<Throwable> {
+            val json = executeScriptAndParseDataframeResult(
+                """
+                data class Row(val id: Int, val group: Int)
+                val df = (1..100).map { Row(it, if (it <= 50) 1 else 2) }.toDataFrame()
+                KotlinNotebookPluginUtils.convertToDataFrame(df.groupBy("group").first())
+                """.trimIndent(),
+            )
+
+            assertDataFrameDimensions(json, 2, 2)
+        }
+    }
+
+    @Test
+    fun `test sortByColumns by int column`() {
+        val json = executeScriptAndParseDataframeResult(
+            """
+            val df = dataFrameOf("nums")(5, 4, 3, 2, 1)
+            val res = KotlinNotebookPluginUtils.sortByColumns(df, listOf(listOf("nums")), listOf(false))
+            KotlinNotebookPluginUtils.convertToDataFrame(res)
+            """.trimIndent(),
+        )
+
+        val rows = json[KOTLIN_DATAFRAME]!!.jsonArray
+        json.extractColumn<Int>(0, "nums") shouldBe 1
+        json.extractColumn<Int>(rows.size - 1, "nums") shouldBe 5
+    }
+
+    internal inline fun <reified T> JsonObject.extractColumn(index: Int, fieldName: String): T {
+        val element = this[KOTLIN_DATAFRAME]!!.jsonArray[index].jsonObject[fieldName]!!.jsonPrimitive
+        return when (T::class) {
+            String::class -> element.content as T
+            Int::class -> element.int as T
+            else -> throw IllegalArgumentException("Unsupported type")
+        }
+    }
+
+    @Test
+    fun `test sortByColumns by multiple int columns`() {
+        val json = executeScriptAndParseDataframeResult(
+            """
+            data class Row(val a: Int, val b: Int)
+            val df = listOf(Row(1, 1), Row(1, 2), Row(2, 3), Row(2, 4), Row(3, 5), Row(3, 6)).toDataFrame()
+            val res = KotlinNotebookPluginUtils.sortByColumns(df, listOf(listOf("a"), listOf("b")), listOf(true, false))
+            KotlinNotebookPluginUtils.convertToDataFrame(res)
+            """.trimIndent(),
+        )
+
+        json.extractColumn<Int>(0, "a") shouldBe 3
+        json.extractColumn<Int>(0, "b") shouldBe 5
+        json.extractColumn<Int>(5, "a") shouldBe 1
+        json.extractColumn<Int>(5, "b") shouldBe 2
+    }
+
+    @Test
+    fun `test sortByColumns by single string column`() {
+        val json = executeScriptAndParseDataframeResult(
+            """
+            val df = dataFrameOf("letters")("e", "d", "c", "b", "a")
+            val res = KotlinNotebookPluginUtils.sortByColumns(df, listOf(listOf("letters")), listOf(true))
+            KotlinNotebookPluginUtils.convertToDataFrame(res)
+            """.trimIndent(),
+        )
+
+        json.extractColumn<String>(0, "letters") shouldBe "e"
+        json.extractColumn<String>(4, "letters") shouldBe "a"
+    }
+
+    @Test
+    fun `test sortByColumns by multiple string columns`() {
+        val json = executeScriptAndParseDataframeResult(
+            """
+            data class Row(val first: String, val second: String)
+            val df = listOf(Row("a", "b"), Row("a", "a"), Row("b", "b"), Row("b", "a")).toDataFrame()
+            val res = KotlinNotebookPluginUtils.sortByColumns(df, listOf(listOf("first"), listOf("second")), listOf(false, true))
+            KotlinNotebookPluginUtils.convertToDataFrame(res)
+            """.trimIndent(),
+        )
+
+        json.extractColumn<String>(0, "first") shouldBe "a"
+        json.extractColumn<String>(0, "second") shouldBe "b"
+        json.extractColumn<String>(3, "first") shouldBe "b"
+        json.extractColumn<String>(3, "second") shouldBe "a"
+    }
+
+    @Test
+    fun `test sortByColumns by mix of int and string columns`() {
+        val json = executeScriptAndParseDataframeResult(
+            """
+            data class Row(val num: Int, val letter: String)
+            val df = listOf(Row(1, "a"), Row(1, "b"), Row(2, "a"), Row(2, "b"), Row(3, "a")).toDataFrame()
+            val res = KotlinNotebookPluginUtils.sortByColumns(df, listOf(listOf("num"), listOf("letter")), listOf(true, false))
+            KotlinNotebookPluginUtils.convertToDataFrame(res)
+            """.trimIndent(),
+        )
+
+        json.extractColumn<Int>(0, "num") shouldBe 3
+        json.extractColumn<String>(0, "letter") shouldBe "a"
+        json.extractColumn<Int>(4, "num") shouldBe 1
+        json.extractColumn<String>(4, "letter") shouldBe "b"
+    }
+
+    @Test
+    fun `test sortByColumns by multiple non-comparable column`() {
+        val json = executeScriptAndParseDataframeResult(
+            """
+            data class Person(val name: String, val age: Int) {
+                override fun toString(): String {
+                    return age.toString()
+                }
+            }
+            val df = dataFrameOf("urls", "person")(
+                URL("https://example.com/a"), Person("Alice", 10), 
+                URL("https://example.com/b"), Person("Bob", 11),
+                URL("https://example.com/a"), Person("Nick", 12),
+                URL("https://example.com/b"), Person("Guy", 13),
+            )
+            val res = KotlinNotebookPluginUtils.sortByColumns(df, listOf(listOf("urls"), listOf("person")), listOf(false, true))
+            KotlinNotebookPluginUtils.convertToDataFrame(res)
+            """.trimIndent(),
+        )
+
+        json.extractColumn<Int>(0, "person") shouldBe 12
+        json.extractColumn<Int>(3, "person") shouldBe 11
+    }
+
+    @Test
+    fun `test sortByColumns by mix of comparable and non-comparable columns`() {
+        val json = executeScriptAndParseDataframeResult(
+            """
+            val df = dataFrameOf("urls", "id")(
+                URL("https://example.com/a"), 1, 
+                URL("https://example.com/b"), 2,
+                URL("https://example.com/a"), 2,
+                URL("https://example.com/b"), 1,
+            )
+            val res = KotlinNotebookPluginUtils.sortByColumns(df, listOf(listOf("id"), listOf("urls")), listOf(true, true))
+            KotlinNotebookPluginUtils.convertToDataFrame(res)
+            """.trimIndent(),
+        )
+
+        json.extractColumn<String>(0, "urls") shouldBe "https://example.com/b"
+        json.extractColumn<Int>(0, "id") shouldBe 2
+        json.extractColumn<String>(3, "urls") shouldBe "https://example.com/a"
+        json.extractColumn<Int>(3, "id") shouldBe 1
+    }
+
+    @Test
+    fun `test sortByColumns by url column`() {
+        val json = executeScriptAndParseDataframeResult(
+            """
+            val df = dataFrameOf("urls")(
+                URL("https://example.com/a"),
+                URL("https://example.com/c"),
+                URL("https://example.com/b"),
+                URL("https://example.com/d")
+            )
+            val res = KotlinNotebookPluginUtils.sortByColumns(df, listOf(listOf("urls")), listOf(false))
+            KotlinNotebookPluginUtils.convertToDataFrame(res)
+            """.trimIndent(),
+        )
+
+        json.extractColumn<String>(0, "urls") shouldBe "https://example.com/a"
+        json.extractColumn<String>(1, "urls") shouldBe "https://example.com/b"
+        json.extractColumn<String>(2, "urls") shouldBe "https://example.com/c"
+        json.extractColumn<String>(3, "urls") shouldBe "https://example.com/d"
+    }
+
+    @Test
+    fun `test sortByColumns by column group children`() {
+        val json = executeScriptAndParseDataframeResult(
+            """
+            val df = dataFrameOf(
+                "a" to listOf(5, 4, 3, 2, 1),
+                "b" to listOf(1, 2, 3, 4, 5)
+            )
+            val res = KotlinNotebookPluginUtils.sortByColumns(df.group("a", "b").into("c"), listOf(listOf("c", "a")), listOf(false))
+            KotlinNotebookPluginUtils.convertToDataFrame(res)
+            """.trimIndent(),
+        )
+
+        fun JsonObject.extractBFields(): List<Int> {
+            val dataframe = this[KOTLIN_DATAFRAME]!!.jsonArray
+            return dataframe.map { it.jsonObject["c"]!!.jsonObject["data"]!!.jsonObject["b"]!!.jsonPrimitive.int }
+        }
+
+        val bFields = json.extractBFields()
+        bFields shouldBe listOf(5, 4, 3, 2, 1)
+    }
+
+    @Test
+    fun `test sortByColumns for column that contains string and int`() {
+        val json = executeScriptAndParseDataframeResult(
+            """
+            val df = dataFrameOf("mixed")(
+                5,
+                "10",
+                2,
+                "4",
+                "1"
+            )
+            val res = KotlinNotebookPluginUtils.sortByColumns(df, listOf(listOf("mixed")), listOf(true))
+            KotlinNotebookPluginUtils.convertToDataFrame(res)
+            """.trimIndent(),
+        )
+
+        json.extractColumn<String>(0, "mixed") shouldBe "5"
+        json.extractColumn<String>(1, "mixed") shouldBe "4"
+        json.extractColumn<String>(2, "mixed") shouldBe "2"
+        json.extractColumn<String>(3, "mixed") shouldBe "10"
+        json.extractColumn<String>(4, "mixed") shouldBe "1"
+    }
+
+    companion object {
+        /**
+         * Set the system property for the IDE version needed for specific serialization testing purposes.
+         */
+        @BeforeClass
+        @JvmStatic
+        internal fun setupOnce() {
+            System.setProperty("KTNB_IDE_BUILD_NUMBER", "IU;241;14015")
+        }
+    }
+}
diff --git a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/jupyter/ResourcesTest.kt b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/jupyter/ResourcesTest.kt
new file mode 100644
index 000000000..36077d14b
--- /dev/null
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/jupyter/ResourcesTest.kt
@@ -0,0 +1,17 @@
+package org.jetbrains.kotlinx.dataframe.jupyter
+
+import io.kotest.matchers.shouldNotBe
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.junit.Test
+import java.io.InputStreamReader
+
+class ResourcesTest {
+
+    @Test
+    fun `resources available`() {
+        val res = DataFrame::class.java.getResourceAsStream("/table.html")
+        println(InputStreamReader(res).readText())
+
+        res shouldNotBe null
+    }
+}
diff --git a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/jupyter/SampleNotebooksTests.kt b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/jupyter/SampleNotebooksTests.kt
new file mode 100644
index 000000000..822e44b3b
--- /dev/null
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/jupyter/SampleNotebooksTests.kt
@@ -0,0 +1,131 @@
+package org.jetbrains.kotlinx.dataframe.jupyter
+
+import org.jetbrains.jupyter.parser.JupyterParser
+import org.jetbrains.jupyter.parser.notebook.CodeCell
+import org.jetbrains.jupyter.parser.notebook.Output
+import org.junit.Ignore
+import org.junit.Test
+import java.io.File
+import java.util.Locale
+
+class SampleNotebooksTests : DataFrameJupyterTest() {
+    @Test
+    @Ignore
+    fun puzzles() = exampleTest("puzzles", "40 puzzles")
+
+    @Test
+    fun github() =
+        exampleTest(
+            dir = "github",
+            cellClause = CellClause.stopAfter { cell ->
+                "personal access token" in cell.source
+            },
+            cleanup = {
+                File("jetbrains.json").delete()
+            },
+        )
+
+    @Test
+    @Ignore
+    fun titanic() =
+        exampleTest(
+            dir = "titanic",
+            notebookName = "Titanic",
+            replacer = CodeReplacer.byMap(
+                "../../idea-examples/" to "$IDEA_EXAMPLES_PATH/",
+            ),
+        )
+
+    @Test
+    @Ignore
+    fun wine() =
+        exampleTest(
+            dir = "wine",
+            notebookName = "WineNetWIthKotlinDL",
+            replacer = CodeReplacer.byMap(
+                testFile("wine", "winequality-red.csv"),
+            ),
+        )
+
+    @Test
+    @Ignore
+    fun netflix() {
+        val currentLocale = Locale.getDefault()
+        try {
+            // Set explicit locale as of test data contains locale-dependent values (date for parsing)
+            Locale.setDefault(Locale.forLanguageTag("en-US"))
+
+            exampleTest(
+                dir = "netflix",
+                replacer = CodeReplacer.byMap(
+                    testFile("netflix", "country_codes.csv"),
+                    testFile("netflix", "netflix_titles.csv"),
+                ),
+            )
+        } finally {
+            Locale.setDefault(currentLocale)
+        }
+    }
+
+    @Test
+    @Ignore
+    fun movies() =
+        exampleTest(
+            dir = "movies",
+            replacer = CodeReplacer.byMap(
+                "ml-latest/movies.csv" to "$IDEA_EXAMPLES_PATH/movies/src/main/resources/movies.csv",
+            ),
+            // There is no tags data in repository
+            cellClause = CellClause.stopAfter { cell ->
+                "tags.csv" in cell.source
+            },
+        )
+
+    private fun doTest(
+        notebookPath: String,
+        replacer: CodeReplacer,
+        cellClause: CellClause,
+        cleanup: () -> Unit = {},
+    ) {
+        val notebookFile = File(notebookPath)
+        val notebook = JupyterParser.parse(notebookFile)
+        val finalClause = cellClause and CellClause.IS_CODE
+
+        val codeCellsData = notebook.cells
+            .filter { finalClause.isAccepted(it) }
+            .map { CodeCellData(it.source, (it as? CodeCell)?.outputs.orEmpty()) }
+
+        try {
+            for (codeCellData in codeCellsData) {
+                val code = codeCellData.code
+                val codeToExecute = replacer.replace(code)
+
+                println("Executing code:\n$codeToExecute")
+                val cellResult = execRendered(codeToExecute)
+                println(cellResult)
+            }
+        } finally {
+            cleanup()
+        }
+    }
+
+    private fun exampleTest(
+        dir: String,
+        notebookName: String? = null,
+        replacer: CodeReplacer = CodeReplacer.DEFAULT,
+        cellClause: CellClause = CellClause { true },
+        cleanup: () -> Unit = {},
+    ) {
+        val fileName = if (notebookName == null) "$dir.ipynb" else "$notebookName.ipynb"
+        doTest("$NOTEBOOK_EXAMPLES_PATH/$dir/$fileName", replacer, cellClause, cleanup)
+    }
+
+    data class CodeCellData(val code: String, val outputs: List<Output>)
+
+    companion object {
+        const val IDEA_EXAMPLES_PATH = "../examples/idea-examples"
+        const val NOTEBOOK_EXAMPLES_PATH = "../examples/notebooks"
+
+        fun testFile(folder: String, fileName: String) = fileName to "$NOTEBOOK_EXAMPLES_PATH/$folder/$fileName"
+    }
+}
diff --git a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/puzzles/BasicTests.kt b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/puzzles/BasicTests.kt
new file mode 100644
index 000000000..4241f7570
--- /dev/null
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/puzzles/BasicTests.kt
@@ -0,0 +1,225 @@
+package org.jetbrains.kotlinx.dataframe.puzzles
+
+import io.kotest.matchers.shouldBe
+import org.jetbrains.kotlinx.dataframe.api.append
+import org.jetbrains.kotlinx.dataframe.api.at
+import org.jetbrains.kotlinx.dataframe.api.cast
+import org.jetbrains.kotlinx.dataframe.api.columnOf
+import org.jetbrains.kotlinx.dataframe.api.convert
+import org.jetbrains.kotlinx.dataframe.api.count
+import org.jetbrains.kotlinx.dataframe.api.dataFrameOf
+import org.jetbrains.kotlinx.dataframe.api.dropLast
+import org.jetbrains.kotlinx.dataframe.api.filter
+import org.jetbrains.kotlinx.dataframe.api.groupBy
+import org.jetbrains.kotlinx.dataframe.api.head
+import org.jetbrains.kotlinx.dataframe.api.mean
+import org.jetbrains.kotlinx.dataframe.api.pivot
+import org.jetbrains.kotlinx.dataframe.api.select
+import org.jetbrains.kotlinx.dataframe.api.sortBy
+import org.jetbrains.kotlinx.dataframe.api.sum
+import org.jetbrains.kotlinx.dataframe.api.take
+import org.jetbrains.kotlinx.dataframe.api.update
+import org.jetbrains.kotlinx.dataframe.api.where
+import org.jetbrains.kotlinx.dataframe.api.with
+import org.jetbrains.kotlinx.dataframe.get
+import org.junit.Test
+import java.text.DecimalFormatSymbols
+import kotlin.reflect.typeOf
+
+@Suppress("ktlint:standard:argument-list-wrapping")
+class BasicTests {
+
+    private val animal by columnOf("cat", "cat", "snake", "dog", "dog", "cat", "snake", "cat", "dog", "dog")
+    private val age by columnOf(2.5, 3.0, 0.5, Double.NaN, 5.0, 2.0, 4.5, Double.NaN, 7.0, 3.0)
+    private val visits by columnOf(1, 3, 2, 3, 2, 3, 1, 1, 2, 1)
+    private val priority by columnOf("yes", "yes", "no", "yes", "no", "no", "no", "yes", "no", "no")
+
+    private val df = dataFrameOf(animal, age, visits, priority)
+
+    @Test
+    fun `return first 3 rows`() {
+        val expected = dataFrameOf("animal", "age", "visits", "priority")(
+            "cat", 2.5, 1, "yes",
+            "cat", 3.0, 3, "yes",
+            "snake", 0.5, 2, "no",
+        )
+
+        df[0 until 3] shouldBe expected
+        df.head(3) shouldBe expected
+        df.take(3) shouldBe expected
+    }
+
+    @Test
+    fun `select animal and age columns from df`() {
+        val expected = dataFrameOf(animal, age)
+
+        df[animal, age] shouldBe expected
+        df["animal", "age"] shouldBe expected
+        df.select { animal and age } shouldBe expected
+        df.select { "animal" and "age" } shouldBe expected
+    }
+
+    @Test
+    fun `select rows (3, 4, 8) and columns (animal, age)`() {
+        val expected = dataFrameOf("animal", "age")(
+            "dog", Double.NaN,
+            "dog", 5.0,
+            "dog", 7.0,
+        )
+
+        df[3, 4, 8][animal, age] shouldBe expected
+        df[3, 4, 8]["animal", "age"] shouldBe expected
+        df.select { animal and age }[3, 4, 8] shouldBe expected
+        df.select { "animal" and "age" }[3, 4, 8] shouldBe expected
+    }
+
+    @Test
+    fun `select only rows where number of visits is grater than 2`() {
+        val expected = dataFrameOf("animal", "age", "visits", "priority")(
+            "cat", 3.0, 3, "yes",
+            "dog", Double.NaN, 3, "yes",
+            "cat", 2.0, 3, "no",
+        )
+
+        df.filter { visits > 2 } shouldBe expected
+        df.filter { "visits"<Int>() > 2 } shouldBe expected
+    }
+
+    @Test
+    fun `select rows where age is missing`() {
+        val expected = dataFrameOf("animal", "age", "visits", "priority")(
+            "dog", Double.NaN, 3, "yes",
+            "cat", Double.NaN, 1, "yes",
+        )
+
+        df.filter { age().isNaN() } shouldBe expected
+        df.filter { "age"<Double>().isNaN() } shouldBe expected
+    }
+
+    @Test
+    fun `select rows where animal is a cat and age is less than 3`() {
+        val expected = dataFrameOf("animal", "age", "visits", "priority")(
+            "cat", 2.5, 1, "yes",
+            "cat", 2.0, 3, "no",
+        )
+
+        df.filter { animal() == "cat" && age() < 3 } shouldBe expected
+        df.filter { "animal"<String>() == "cat" && "age"<Double>() < 3 } shouldBe expected
+    }
+
+    @Test
+    fun `select rows where age is between 2 and 4 (inclusive)`() {
+        val expected = dataFrameOf("animal", "age", "visits", "priority")(
+            "cat", 2.5, 1, "yes",
+            "cat", 3.0, 3, "yes",
+            "cat", 2.0, 3, "no",
+            "dog", 3.0, 1, "no",
+        )
+
+        df.filter { age() in 2.0..4.0 } shouldBe expected
+        df.filter { "age"() in 2.0..4.0 } shouldBe expected
+    }
+
+    @Test
+    fun `change age in row 5 to 1,5`() {
+        val dfActualAcc0 = df.update { age }.at(5).with { 1.5 }
+        val dfActualAcc1 = df.update { "age"<Double>() }.at(5).with { 1.5 }
+
+        dfActualAcc0[5][age] shouldBe 1.5
+        dfActualAcc1[5]["age"] shouldBe 1.5
+    }
+
+    @Test
+    fun `calculate sum of all visits`() {
+        df[visits].sum() shouldBe 19
+        df.sum { visits } shouldBe 19
+
+        df["visits"].cast<Int>().sum() shouldBe 19
+        df.sum { "visits"<Int>() } shouldBe 19
+        df.sum("visits") shouldBe 19
+    }
+
+    @Test
+    fun `calculate mean age for each animal`() {
+        val expected = dataFrameOf("animal", "age")(
+            "cat", Double.NaN,
+            "snake", 2.5,
+            "dog", Double.NaN,
+        )
+
+        df.groupBy { animal }.mean { age } shouldBe expected
+        df.groupBy("animal").mean("age") shouldBe expected
+    }
+
+    @Test
+    fun `append and drop new row`() {
+        val modifiedDf = df.append("dog", 5.5, 2, "no")
+
+        val d = DecimalFormatSymbols.getInstance().decimalSeparator
+        modifiedDf[10].toString() shouldBe "{ animal:dog, age:5${d}500000, visits:2, priority:no }"
+
+        modifiedDf.dropLast() shouldBe df
+    }
+
+    @Test
+    fun `count number of each type of animal`() {
+        val expected = dataFrameOf("animal", "count")(
+            "cat", 4,
+            "snake", 2,
+            "dog", 4,
+        )
+
+        df.groupBy { animal }.count() shouldBe expected
+        df.groupBy("animal").count() shouldBe expected
+    }
+
+    @Test
+    fun `sort df first by the values in age in descending order, then by in visit in ascending order`() {
+        val expected = dataFrameOf("age", "visits")(4.5, 1, 3.0, 1, 3.0, 3)
+
+        val sortDfAcc = df.sortBy { age.desc() and visits }
+        val sortDfStr = df.sortBy { "age".desc() and "visits" }
+
+        sortDfAcc[age, visits][4..6] shouldBe expected
+        sortDfStr["age", "visits"][4..6] shouldBe expected
+    }
+
+    @Test
+    fun `replace priority column to boolean values`() {
+        val convertedDfAcc = df.convert { priority }.with { it == "yes" }
+        val convertedDfStr = df.convert { "priority"<String>() }.with { it == "yes" }
+
+        convertedDfAcc[priority].type() shouldBe typeOf<Boolean>()
+        convertedDfAcc["priority"].type() shouldBe typeOf<Boolean>()
+
+        convertedDfStr[priority][5] shouldBe false
+        convertedDfStr["priority"][5] shouldBe false
+    }
+
+    @Test
+    fun `change dog to corgi`() {
+        val updatedDfAcc = df.update { animal }.where { it == "dog" }.with { "corgi" }
+        val updatedDfStr = df.update("animal").where { it == "dog" }.with { "corgi" }
+
+        updatedDfAcc[animal][3] shouldBe "corgi"
+        updatedDfAcc[animal][8] shouldBe "corgi"
+
+        updatedDfStr["animal"][3] shouldBe "corgi"
+        updatedDfStr["animal"][8] shouldBe "corgi"
+    }
+
+    @Test
+    fun `find mean age for each animal type and number of visits`() {
+        val expected = dataFrameOf("animal", "1", "3", "2")(
+            "cat", 2.5, 2.5, null,
+            "snake", 4.5, null, 0.5,
+            "dog", 3.0, Double.NaN, 6.0,
+        )
+
+        val actualDfAcc = df.pivot(inward = false) { visits }.groupBy { animal }.mean(skipNA = true) { age }
+        val actualDfStr = df.pivot("visits", inward = false).groupBy("animal").mean("age", skipNA = true)
+
+        actualDfAcc shouldBe expected
+        actualDfStr shouldBe expected
+    }
+}
diff --git a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/puzzles/CleaningDataTests.kt b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/puzzles/CleaningDataTests.kt
new file mode 100644
index 000000000..2e91b0359
--- /dev/null
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/puzzles/CleaningDataTests.kt
@@ -0,0 +1,132 @@
+package org.jetbrains.kotlinx.dataframe.puzzles
+
+import io.kotest.matchers.shouldBe
+import org.jetbrains.kotlinx.dataframe.api.by
+import org.jetbrains.kotlinx.dataframe.api.column
+import org.jetbrains.kotlinx.dataframe.api.columnOf
+import org.jetbrains.kotlinx.dataframe.api.convert
+import org.jetbrains.kotlinx.dataframe.api.dataFrameOf
+import org.jetbrains.kotlinx.dataframe.api.default
+import org.jetbrains.kotlinx.dataframe.api.into
+import org.jetbrains.kotlinx.dataframe.api.named
+import org.jetbrains.kotlinx.dataframe.api.next
+import org.jetbrains.kotlinx.dataframe.api.prev
+import org.jetbrains.kotlinx.dataframe.api.split
+import org.jetbrains.kotlinx.dataframe.api.toColumn
+import org.jetbrains.kotlinx.dataframe.api.toInt
+import org.jetbrains.kotlinx.dataframe.api.update
+import org.jetbrains.kotlinx.dataframe.api.where
+import org.jetbrains.kotlinx.dataframe.api.with
+import org.jetbrains.kotlinx.dataframe.get
+import org.junit.Test
+
+@Suppress("ktlint:standard:argument-list-wrapping")
+class CleaningDataTests {
+
+    private val fromTo = listOf(
+        "LoNDon_paris",
+        "MAdrid_miLAN",
+        "londON_StockhOlm",
+        "Budapest_PaRis",
+        "Brussels_londOn",
+    ).toColumn("From_To")
+    private val flightNumber = listOf(10045.0, Double.NaN, 10065.0, Double.NaN, 10085.0).toColumn("FlightNumber")
+    private val recentDelays =
+        listOf(listOf(23, 47), listOf(), listOf(24, 43, 87), listOf(13), listOf(67, 32)).toColumn("RecentDelays")
+    private val airline = listOf(
+        "KLM(!)",
+        "{Air France} (12)",
+        "(British Airways. )",
+        "12. Air France",
+        "'Swiss Air'",
+    ).toColumn("Airline")
+
+    private var df = dataFrameOf(fromTo, flightNumber, recentDelays, airline)
+
+    @Test
+    fun `interpolate test`() {
+        val expected = columnOf(10045, 10055, 10065, 10075, 10085).named("FlightNumber")
+
+        df.update { flightNumber }.where { it.isNaN() }.with {
+            prev()!![flightNumber] + (next()!![flightNumber] - prev()!![flightNumber]) / 2
+        }.convert { flightNumber }.toInt()[flightNumber] shouldBe expected
+
+        df.update { "FlightNumber"<Double>() }.where { it.isNaN() }.with {
+            prev()!![{ "FlightNumber"<Double>() }] + (
+                next()!![{ "FlightNumber"<Double>() }] - prev()!![{ "FlightNumber"<Double>() }]
+            ) / 2
+        }.convert { flightNumber }.toInt()["FlightNumber"] shouldBe expected
+    }
+
+    @Test
+    fun `split From_To`() {
+        val expected = dataFrameOf("From", "To")(
+            "LoNDon", "paris",
+            "MAdrid", "miLAN",
+            "londON", "StockhOlm",
+            "Budapest", "PaRis",
+            "Brussels", "londOn",
+        )
+
+        df.split { fromTo }.by('_').into("From", "To")["From", "To"] shouldBe expected
+        df.split { "From_To"<String>() }.by('_').into("From", "To")["From", "To"] shouldBe expected
+    }
+
+    @Test
+    fun `uppercase for cities`() {
+        val from by column<String>("From")
+        val to by column<String>("To")
+
+        val expected = dataFrameOf("From", "To")(
+            "London", "Paris",
+            "Madrid", "Milan",
+            "London", "Stockholm",
+            "Budapest", "Paris",
+            "Brussels", "London",
+        )
+
+        df.split { fromTo }.by('_').into("From", "To")[from, to]
+            .update { from and to }.with { it.lowercase().replaceFirstChar(Char::uppercase) } shouldBe expected
+
+        df.split { "From_To"<String>() }.by('_').into("From", "To")["From", "To"]
+            .update { "From"<String>() and "To"<_>() }.with {
+                it.lowercase().replaceFirstChar(Char::uppercase)
+            } shouldBe expected
+    }
+
+    @Test
+    fun `airline test`() {
+        val expected = columnOf("KLM", "Air France", "British Airways", "Air France", "Swiss Air").named("Airline")
+
+        df.update { airline }.with {
+            "([a-zA-Z\\s]+)".toRegex().find(it)?.value?.trim() ?: ""
+        }[airline] shouldBe expected
+
+        df.update { "Airline"<String>() }.with {
+            "([a-zA-Z\\s]+)".toRegex().find(it)?.value?.trim() ?: ""
+        }["Airline"] shouldBe expected
+    }
+
+    @Test
+    fun `split delays`() {
+        val delay1 by column<Double>("delay_1")
+        val delay2 by column<Double>("delay_2")
+        val delay3 by column<Double>("delay_3")
+
+        val expected = dataFrameOf("delay_1", "delay_2", "delay_3")(
+            23.0, 47.0, Double.NaN,
+            Double.NaN, Double.NaN, Double.NaN,
+            24.0, 43.0, 87.0,
+            13.0, Double.NaN, Double.NaN,
+            67.0, 32.0, Double.NaN,
+        )
+
+        df.convert { recentDelays }.with { it.map { d -> d.toDouble() } }
+            .split { recentDelays }.default(Double.NaN).into { "delay_$it" }[delay1, delay2, delay3] shouldBe expected
+
+        df.convert { "RecentDelays"<List<Int>>() }.with { it.map { d -> d.toDouble() } }
+            .split { "RecentDelays"<List<Double>>() }.default(Double.NaN).into {
+                "delay_$it"
+            }[delay1, delay2, delay3] shouldBe expected
+    }
+}
diff --git a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/puzzles/DateTestUtils.kt b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/puzzles/DateTestUtils.kt
new file mode 100644
index 000000000..767d738cf
--- /dev/null
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/puzzles/DateTestUtils.kt
@@ -0,0 +1,42 @@
+package org.jetbrains.kotlinx.dataframe.puzzles
+
+import kotlinx.datetime.DateTimeUnit
+import kotlinx.datetime.LocalDate
+import kotlinx.datetime.daysUntil
+import kotlinx.datetime.plus
+
+class DateRangeIterator(first: LocalDate, last: LocalDate, val step: Int) : Iterator<LocalDate> {
+    private val finalElement: LocalDate = last
+    private var hasNext: Boolean = if (step > 0) first <= last else first >= last
+    private var next: LocalDate = if (hasNext) first else finalElement
+
+    override fun hasNext(): Boolean = hasNext
+
+    override fun next(): LocalDate {
+        val value = next
+        if (value == finalElement) {
+            if (!hasNext) throw kotlin.NoSuchElementException()
+            hasNext = false
+        } else {
+            next = next.plus(step, DateTimeUnit.DayBased(1))
+        }
+        return value
+    }
+}
+
+operator fun ClosedRange<LocalDate>.iterator() = DateRangeIterator(this.start, this.endInclusive, 1)
+
+fun ClosedRange<LocalDate>.toList(): List<LocalDate> =
+    when (val size = this.start.daysUntil(this.endInclusive)) {
+        0 -> emptyList()
+
+        1 -> listOf(iterator().next())
+
+        else -> {
+            val dest = ArrayList<LocalDate>(size)
+            for (item in this) {
+                dest.add(item)
+            }
+            dest
+        }
+    }
diff --git a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/puzzles/DateTests.kt b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/puzzles/DateTests.kt
new file mode 100644
index 000000000..9358d9d00
--- /dev/null
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/puzzles/DateTests.kt
@@ -0,0 +1,119 @@
+package org.jetbrains.kotlinx.dataframe.puzzles
+
+import io.kotest.matchers.shouldBe
+import kotlinx.datetime.LocalDate
+import kotlinx.datetime.Month
+import kotlinx.datetime.toJavaLocalDate
+import org.jetbrains.kotlinx.dataframe.api.add
+import org.jetbrains.kotlinx.dataframe.api.aggregate
+import org.jetbrains.kotlinx.dataframe.api.column
+import org.jetbrains.kotlinx.dataframe.api.columnOf
+import org.jetbrains.kotlinx.dataframe.api.dataFrameOf
+import org.jetbrains.kotlinx.dataframe.api.filter
+import org.jetbrains.kotlinx.dataframe.api.flatten
+import org.jetbrains.kotlinx.dataframe.api.groupBy
+import org.jetbrains.kotlinx.dataframe.api.map
+import org.jetbrains.kotlinx.dataframe.api.maxBy
+import org.jetbrains.kotlinx.dataframe.api.mean
+import org.jetbrains.kotlinx.dataframe.api.named
+import org.jetbrains.kotlinx.dataframe.api.sum
+import org.jetbrains.kotlinx.dataframe.api.toColumn
+import org.jetbrains.kotlinx.dataframe.get
+import org.junit.Test
+import java.time.temporal.WeekFields
+import java.util.Locale
+import kotlin.math.round
+import kotlin.random.Random
+
+@Suppress("ktlint:standard:argument-list-wrapping")
+class DateTests {
+
+    private val start = LocalDate(2015, 1, 1)
+    private val end = LocalDate(2016, 1, 1)
+    private val dti = (start..end).toList().toColumn("dti")
+    private val random = Random(42)
+    private val s = List(dti.size()) { random.nextDouble() }.toColumn("s")
+    private val df = dataFrameOf(dti, s)
+
+    @Test
+    fun `sum for every Wednesday`() {
+        round(df.filter { dti().dayOfWeek.ordinal == 2 }.sum { s }) shouldBe 29.0
+        round(df.filter { "dti"<LocalDate>().dayOfWeek.ordinal == 2 }.sum { "s"<Double>() }) shouldBe 29.0
+    }
+
+    @Test
+    fun `mean for each calendar month`() {
+        val expected = dataFrameOf("month", "s")(
+            Month.JANUARY, 0.4931329003584097,
+            Month.FEBRUARY, 0.5712887136099648,
+            Month.MARCH, 0.5263142140806993,
+            Month.APRIL, 0.5125149149109348,
+            Month.MAY, 0.5030292029672427,
+            Month.JUNE, 0.4691575481416088,
+            Month.JULY, 0.5533841389695694,
+            Month.AUGUST, 0.5661103164088407,
+            Month.SEPTEMBER, 0.44344455128172383,
+            Month.OCTOBER, 0.41726495068242264,
+            Month.NOVEMBER, 0.43862977969202627,
+            Month.DECEMBER, 0.5130316016982762,
+        )
+
+        df.groupBy { dti.map { it.month } named "month" }.mean() shouldBe expected
+        df.groupBy { "dti"<LocalDate>().map { it.month } named "month" }.mean() shouldBe expected
+    }
+
+    @Test
+    fun `find date on which highest value`() {
+        val expected = dataFrameOf("month4", "dti", "month41")(
+            1, LocalDate(2015, 2, 11), 1,
+            2, LocalDate(2015, 8, 25), 2,
+            3, LocalDate(2015, 9, 2), 3,
+        )
+        val month4 by column<Int>()
+        val month41 by column<Int>()
+
+        df.add("month4") {
+            when (dti().monthNumber) {
+                in 1..4 -> 1
+                in 5..8 -> 2
+                else -> 3
+            }
+        }.groupBy("month4").aggregate { maxBy(s) into "max" }
+            .flatten()[month4, dti, month41] shouldBe expected
+
+        df.add("month4") {
+            when ("dti"<LocalDate>().monthNumber) {
+                in 1..4 -> 1
+                in 5..8 -> 2
+                else -> 3
+            }
+        }.groupBy("month4").aggregate { maxBy("s") into "max" }
+            .flatten()["month4", "dti", "month41"] shouldBe expected
+    }
+
+    @Test
+    fun `create column consisting of the third Thursday in each month`() {
+        val start = LocalDate(2015, 1, 1)
+        val end = LocalDate(2015, 12, 31)
+
+        val expected = columnOf(
+            LocalDate(2015, 1, 15),
+            LocalDate(2015, 2, 19),
+            LocalDate(2015, 3, 19),
+            LocalDate(2015, 4, 16),
+            LocalDate(2015, 5, 14),
+            LocalDate(2015, 6, 18),
+            LocalDate(2015, 7, 16),
+            LocalDate(2015, 8, 13),
+            LocalDate(2015, 9, 17),
+            LocalDate(2015, 10, 15),
+            LocalDate(2015, 11, 19),
+            LocalDate(2015, 12, 17),
+        ).named("3thu")
+
+        (start..end).toList().toColumn("3thu").filter {
+            it.toJavaLocalDate()[WeekFields.of(Locale.ENGLISH).weekOfMonth()] == 3 &&
+                it.dayOfWeek.value == 4
+        } shouldBe expected
+    }
+}
diff --git a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/puzzles/HardTests.kt b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/puzzles/HardTests.kt
new file mode 100644
index 000000000..8ab0a78da
--- /dev/null
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/puzzles/HardTests.kt
@@ -0,0 +1,144 @@
+package org.jetbrains.kotlinx.dataframe.puzzles
+
+import io.kotest.matchers.shouldBe
+import org.jetbrains.kotlinx.dataframe.api.add
+import org.jetbrains.kotlinx.dataframe.api.column
+import org.jetbrains.kotlinx.dataframe.api.columnOf
+import org.jetbrains.kotlinx.dataframe.api.concat
+import org.jetbrains.kotlinx.dataframe.api.dataFrameOf
+import org.jetbrains.kotlinx.dataframe.api.filter
+import org.jetbrains.kotlinx.dataframe.api.gather
+import org.jetbrains.kotlinx.dataframe.api.groupBy
+import org.jetbrains.kotlinx.dataframe.api.into
+import org.jetbrains.kotlinx.dataframe.api.mapToColumn
+import org.jetbrains.kotlinx.dataframe.api.mean
+import org.jetbrains.kotlinx.dataframe.api.named
+import org.jetbrains.kotlinx.dataframe.api.pivot
+import org.jetbrains.kotlinx.dataframe.api.prev
+import org.jetbrains.kotlinx.dataframe.api.relative
+import org.jetbrains.kotlinx.dataframe.api.remove
+import org.jetbrains.kotlinx.dataframe.api.sortBy
+import org.jetbrains.kotlinx.dataframe.api.sortByDesc
+import org.jetbrains.kotlinx.dataframe.api.take
+import org.jetbrains.kotlinx.dataframe.api.toDataFrame
+import org.jetbrains.kotlinx.dataframe.api.values
+import org.jetbrains.kotlinx.dataframe.get
+import org.junit.Test
+import kotlin.math.round
+import kotlin.random.Random
+
+@Suppress("ktlint:standard:argument-list-wrapping")
+class HardTests {
+
+    @Test
+    fun `count difference back to previous zero`() {
+        val x = columnOf(7, 2, 0, 3, 4, 2, 5, 0, 3, 4).named("X")
+        val df = x.toDataFrame()
+        val y = columnOf(1, 2, 0, 1, 2, 3, 4, 0, 1, 2).named("Y")
+
+        df.mapToColumn("Y") {
+            if (it[x] == 0) 0 else (prev()?.newValue() ?: 0) + 1
+        } shouldBe y
+
+        df.mapToColumn("Y") {
+            if (it["X"] == 0) 0 else (prev()?.newValue() ?: 0) + 1
+        } shouldBe y
+    }
+
+    @Test
+    fun `3 largest values`() {
+        val names = ('a'..'h').map { it.toString() }
+        val random = Random(30)
+        val list = List(64) { random.nextInt(1, 101) }
+        val df = dataFrameOf(names)(*list.toTypedArray())
+        val index by column<Int>()
+        val vals by column<Int>()
+        val name by column<String>()
+
+        val expected = dataFrameOf("index", "name")(0, "d", 2, "c", 3, "f")
+
+        df.add("index") { index() }
+            .gather { dropLast() }.into("name", "vals")
+            .sortByDesc { vals }.take(3)[index, name] shouldBe expected
+
+        df.add("index") { index() }
+            .gather { dropLast() }.into("name", "vals")
+            .sortByDesc("vals").take(3)["index", "name"] shouldBe expected
+    }
+
+    @Test
+    fun `group mean and negative values`() {
+        val random = Random(31)
+        val lab = listOf("A", "B")
+
+        val vals by columnOf(*Array(15) { random.nextInt(-30, 30) })
+        val grps by columnOf(*Array(15) { lab[random.nextInt(0, 2)] })
+
+        val df = dataFrameOf(vals, grps)
+
+        val expected = dataFrameOf("vals", "grps", "patched_values")(
+            -17, "B", 21.0,
+            -7, "B", 21.0,
+            16, "A", 16.0,
+            28, "B", 28.0,
+            9, "A", 9.0,
+            16, "B", 16.0,
+            -21, "B", 21.0,
+            -14, "A", 16.0,
+            -19, "A", 16.0,
+            -22, "A", 16.0,
+            19, "B", 19.0,
+            -2, "B", 21.0,
+            -1, "A", 16.0,
+            -19, "B", 21.0,
+            23, "A", 23.0,
+        )
+
+        val means = df
+            .filter { vals >= 0 }
+            .groupBy { grps }.mean()
+            .pivot { grps }.values { vals }
+
+        df.add("patched_values") {
+            if (vals() < 0) means[grps()] as Double else vals().toDouble()
+        } shouldBe expected
+
+        val meansStr = df
+            .filter { "vals"<Int>() >= 0 }
+            .groupBy("grps").mean()
+            .pivot("grps").values("vals")
+
+        df.add("patched_values") {
+            if ("vals"<Int>() < 0) meansStr["grps"<String>()] as Double else "vals"<Int>().toDouble()
+        } shouldBe expected
+    }
+
+    @Test
+    fun `rolling mean`() {
+        val groups by columnOf("a", "a", "b", "b", "a", "b", "b", "b", "a", "b", "a", "b")
+        val value by columnOf(1.0, 2.0, 3.0, Double.NaN, 2.0, 3.0, Double.NaN, 1.0, 7.0, 3.0, Double.NaN, 8.0)
+        val df = dataFrameOf(groups, value)
+
+        val expected = dataFrameOf("groups", "value", "res")(
+            "a", 1.0, 1.0,
+            "a", 2.0, 2.0,
+            "b", 3.0, 3.0,
+            "b", Double.NaN, 3.0,
+            "a", 2.0, 2.0,
+            "b", 3.0, 3.0,
+            "b", Double.NaN, 3.0,
+            "b", 1.0, 2.0,
+            "a", 7.0, 4.0,
+            "b", 3.0, 2.0,
+            "a", Double.NaN, 4.0,
+            "b", 8.0, 4.0,
+        )
+
+        df.add("id") { index() }
+            .groupBy { groups }.add("res") {
+                round(relative(-2..0)[value].filter { !it.isNaN() }.mean())
+            }.concat()
+            .sortBy("id")
+            .remove("id") shouldBe expected
+    }
+}
diff --git a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/puzzles/MediumTests.kt b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/puzzles/MediumTests.kt
new file mode 100644
index 000000000..72fd1dc4d
--- /dev/null
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/puzzles/MediumTests.kt
@@ -0,0 +1,159 @@
+package org.jetbrains.kotlinx.dataframe.puzzles
+
+import io.kotest.matchers.shouldBe
+import org.jetbrains.kotlinx.dataframe.api.aggregate
+import org.jetbrains.kotlinx.dataframe.api.colsOf
+import org.jetbrains.kotlinx.dataframe.api.column
+import org.jetbrains.kotlinx.dataframe.api.columnOf
+import org.jetbrains.kotlinx.dataframe.api.convert
+import org.jetbrains.kotlinx.dataframe.api.countDistinct
+import org.jetbrains.kotlinx.dataframe.api.dataFrameOf
+import org.jetbrains.kotlinx.dataframe.api.diffOrNull
+import org.jetbrains.kotlinx.dataframe.api.filter
+import org.jetbrains.kotlinx.dataframe.api.groupBy
+import org.jetbrains.kotlinx.dataframe.api.isNaN
+import org.jetbrains.kotlinx.dataframe.api.map
+import org.jetbrains.kotlinx.dataframe.api.mapToColumn
+import org.jetbrains.kotlinx.dataframe.api.minBy
+import org.jetbrains.kotlinx.dataframe.api.name
+import org.jetbrains.kotlinx.dataframe.api.named
+import org.jetbrains.kotlinx.dataframe.api.namedValuesOf
+import org.jetbrains.kotlinx.dataframe.api.prev
+import org.jetbrains.kotlinx.dataframe.api.rowMean
+import org.jetbrains.kotlinx.dataframe.api.sortBy
+import org.jetbrains.kotlinx.dataframe.api.sortDesc
+import org.jetbrains.kotlinx.dataframe.api.sum
+import org.jetbrains.kotlinx.dataframe.api.take
+import org.jetbrains.kotlinx.dataframe.api.transpose
+import org.jetbrains.kotlinx.dataframe.api.transposeTo
+import org.jetbrains.kotlinx.dataframe.api.value
+import org.jetbrains.kotlinx.dataframe.api.with
+import org.junit.Test
+import kotlin.math.roundToInt
+import kotlin.random.Random
+import kotlin.random.nextInt
+
+@Suppress("ktlint:standard:argument-list-wrapping")
+class MediumTests {
+
+    private val random = Random(42)
+
+    @Test
+    fun `filter rows that contain same value as row above`() {
+        val df = dataFrameOf("A")(1, 2, 2, 3, 4, 5, 5, 5, 6, 7, 7)
+        val a by column<Int>("A")
+
+        val expected = dataFrameOf("A")(1, 2, 3, 4, 5, 6, 7)
+
+        df.filter { prev()?.get(a) != a() } shouldBe expected
+        df.filter { prev()?.get("A") != "A"() } shouldBe expected
+
+        df.filter { diffOrNull { a() } != 0 } shouldBe expected
+        df.filter { diffOrNull { "A"<Int>() } != 0 } shouldBe expected
+    }
+
+    @Test
+    fun `subtract row mean from each element in row`() {
+        val df = dataFrameOf("a", "b", "c")(
+            1.0, 2.0, 3.0,
+            1.3, 2.3, 3.3,
+            1.57, 2.57, 3.57,
+        )
+
+        val expected = dataFrameOf("a", "b", "c")(
+            -1, 0, 1,
+            -1, 0, 1,
+            -1, 0, 1,
+        )
+
+        df.convert { colsOf<Double>() }.with { (it - rowMean()).roundToInt() } shouldBe expected
+    }
+
+    @Test
+    fun `smallest sum`() {
+        val names = ('a'..'j').map { it.toString() }
+        val df = dataFrameOf(names) { List(5) { random.nextDouble() } }
+
+        df
+            .sum()
+            .transposeTo<Double>()
+            .minBy { value }
+            .name shouldBe "b"
+        df.sum().transpose().minBy("value")["name"] shouldBe "b"
+    }
+
+    @Test
+    fun `count unique rows`() {
+        val df = dataFrameOf("a", "b", "c") { List(30) { random.nextInt(0..2) } }
+        df.countDistinct() shouldBe 19
+    }
+
+    @Test
+    fun `find column which contains third NaN value`() {
+        val nan = Double.NaN
+        val names = ('a'..'j').map { it.toString() }
+        val df = dataFrameOf(names)(
+            0.04, nan, nan, 0.25, nan, 0.43, 0.71, 0.51, nan, nan,
+            nan, nan, nan, 0.04, 0.76, nan, nan, 0.67, 0.76, 0.16,
+            nan, nan, 0.5, nan, 0.31, 0.4, nan, nan, 0.24, 0.01,
+            0.49, nan, nan, 0.62, 0.73, 0.26, 0.85, nan, nan, nan,
+            nan, nan, 0.41, nan, 0.05, nan, 0.61, nan, 0.48, 0.68,
+        )
+
+        val expected = columnOf("e", "c", "d", "h", "d").named("res")
+
+        df.mapToColumn("res") {
+            namedValuesOf<Double>()
+                .filter { it.value.isNaN }
+                .drop(2)
+                .firstOrNull()
+                ?.name
+        } shouldBe expected
+    }
+
+    @Test
+    fun `sum of three greatest values`() {
+        val grps by columnOf("a", "a", "a", "b", "b", "c", "a", "a", "b", "c", "c", "c", "b", "b", "c")
+        val vals by columnOf(12, 345, 3, 1, 45, 14, 4, 52, 54, 23, 235, 21, 57, 3, 87)
+        val df = dataFrameOf(grps, vals)
+
+        val expected = dataFrameOf("grps", "res")("a", 409, "b", 156, "c", 345)
+
+        df.groupBy { grps }.aggregate {
+            vals().sortDesc().take(3).sum() into "res"
+        } shouldBe expected
+
+        df.groupBy { grps }.aggregate {
+            "vals"<Int>().sortDesc().take(3).sum() into "res"
+        } shouldBe expected
+    }
+
+    @Test
+    fun `sum bins`() {
+        val list = List(200) { random.nextInt(1, 101) }
+        val df = dataFrameOf("A", "B")(*list.toTypedArray())
+        val a by column<Int>("A")
+        val b by column<Int>("B")
+
+        val expected = dataFrameOf("A", "B")(
+            "(0, 10]", 353,
+            "(10, 20]", 873,
+            "(20, 30]", 321,
+            "(30, 40]", 322,
+            "(40, 50]", 432,
+            "(50, 60]", 754,
+            "(60, 70]", 405,
+            "(70, 80]", 561,
+            "(80, 90]", 657,
+            "(90, 100]", 527,
+        )
+
+        df.groupBy { a.map { (it - 1) / 10 } }.sum { b }
+            .sortBy { a }
+            .convert { a }.with { "(${it * 10}, ${it * 10 + 10}]" } shouldBe expected
+
+        df.groupBy { "A"<Int>().map { (it - 1) / 10 } }.sum("B")
+            .sortBy("A")
+            .convert { "A"<Int>() }.with { "(${it * 10}, ${it * 10 + 10}]" } shouldBe expected
+    }
+}
diff --git a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/rendering/PrecisionTests.kt b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/rendering/PrecisionTests.kt
new file mode 100644
index 000000000..689605ba4
--- /dev/null
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/rendering/PrecisionTests.kt
@@ -0,0 +1,45 @@
+package org.jetbrains.kotlinx.dataframe.rendering
+
+import io.kotest.matchers.shouldBe
+import org.jetbrains.kotlinx.dataframe.api.columnOf
+import org.jetbrains.kotlinx.dataframe.api.filter
+import org.jetbrains.kotlinx.dataframe.impl.scale
+import org.jetbrains.kotlinx.dataframe.io.DEFAULT_PRECISION
+import org.jetbrains.kotlinx.dataframe.io.RendererDecimalFormat
+import org.jetbrains.kotlinx.dataframe.io.format
+import org.junit.Test
+import java.text.DecimalFormatSymbols
+
+class PrecisionTests {
+
+    @Test
+    fun precision() {
+        columnOf(1.2, 3.2).scale() shouldBe 1
+        columnOf(1.1232, 3.2).scale() shouldBe 4
+        columnOf(1.1220001, 12313).scale() shouldBe DEFAULT_PRECISION
+        columnOf(1, 2).scale() shouldBe 0
+        columnOf(1.0, 2).scale() shouldBe 1
+        columnOf(123121.0, -1231.0).scale() shouldBe 1
+        columnOf(123121.00001, -1231.120).scale() shouldBe 5
+        columnOf(0.000343434343434343434343).scale() shouldBe DEFAULT_PRECISION
+        columnOf(1E24).scale() shouldBe -23
+    }
+
+    @Test
+    fun format() {
+        val d = DecimalFormatSymbols.getInstance().decimalSeparator
+        val value = 1.2341
+        val expected = "1${d}23"
+        val digits = 2
+        val formatter = RendererDecimalFormat.fromPrecision(digits)
+        value.format(formatter) shouldBe expected
+        value.toFloat().format(formatter) shouldBe expected
+        value.toBigDecimal().format(formatter) shouldBe expected
+    }
+
+    @Test
+    fun emptyColPrecision() {
+        val col by columnOf(1.0)
+        col.filter { false }.scale() shouldBe 0
+    }
+}
diff --git a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/rendering/RenderingTests.kt b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/rendering/RenderingTests.kt
new file mode 100644
index 000000000..9bb63eb25
--- /dev/null
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/rendering/RenderingTests.kt
@@ -0,0 +1,199 @@
+package org.jetbrains.kotlinx.dataframe.rendering
+
+import io.kotest.matchers.shouldBe
+import io.kotest.matchers.string.shouldContain
+import io.kotest.matchers.string.shouldNotContain
+import org.jetbrains.kotlinx.dataframe.DataColumn
+import org.jetbrains.kotlinx.dataframe.api.add
+import org.jetbrains.kotlinx.dataframe.api.asColumnGroup
+import org.jetbrains.kotlinx.dataframe.api.columnOf
+import org.jetbrains.kotlinx.dataframe.api.dataFrameOf
+import org.jetbrains.kotlinx.dataframe.api.emptyDataFrame
+import org.jetbrains.kotlinx.dataframe.api.group
+import org.jetbrains.kotlinx.dataframe.api.into
+import org.jetbrains.kotlinx.dataframe.api.move
+import org.jetbrains.kotlinx.dataframe.api.named
+import org.jetbrains.kotlinx.dataframe.api.parse
+import org.jetbrains.kotlinx.dataframe.api.schema
+import org.jetbrains.kotlinx.dataframe.api.toDataFrame
+import org.jetbrains.kotlinx.dataframe.io.DisplayConfiguration
+import org.jetbrains.kotlinx.dataframe.io.escapeHTML
+import org.jetbrains.kotlinx.dataframe.io.formatter
+import org.jetbrains.kotlinx.dataframe.io.maxDepth
+import org.jetbrains.kotlinx.dataframe.io.maxWidth
+import org.jetbrains.kotlinx.dataframe.io.print
+import org.jetbrains.kotlinx.dataframe.io.renderToString
+import org.jetbrains.kotlinx.dataframe.io.renderToStringTable
+import org.jetbrains.kotlinx.dataframe.io.toHTML
+import org.jetbrains.kotlinx.dataframe.jupyter.DefaultCellRenderer
+import org.jetbrains.kotlinx.dataframe.jupyter.RenderedContent
+import org.jetbrains.kotlinx.dataframe.samples.api.TestBase
+import org.jetbrains.kotlinx.dataframe.samples.api.firstName
+import org.jetbrains.kotlinx.dataframe.samples.api.lastName
+import org.jetbrains.kotlinx.dataframe.samples.api.name
+import org.jetbrains.kotlinx.dataframe.samples.api.secondName
+import org.jsoup.Jsoup
+import org.junit.Test
+import java.net.URL
+import java.text.DecimalFormatSymbols
+import kotlin.reflect.typeOf
+
+class RenderingTests : TestBase() {
+
+    @Test
+    fun `render row with unicode values as table`() {
+        val value = "Шёл Шива по шоссе, сокрушая сущее.\r\nА на встречу Саша шла, круглое сосущая"
+        val col by columnOf(value)
+        val df = col.toDataFrame()
+        val rendered = df[0].renderToStringTable()
+        rendered shouldContain "Шива"
+        rendered shouldNotContain "\n"
+        rendered shouldNotContain "\r"
+        rendered shouldContain "\\r"
+        rendered shouldContain "А"
+        rendered shouldContain "..."
+        rendered shouldNotContain "Саша"
+    }
+
+    @Test
+    fun `parse url`() {
+        val df = dataFrameOf("url")("http://www.google.com").parse()
+        df["url"].type() shouldBe typeOf<URL>()
+    }
+
+    @Test
+    fun htmlTagsAreEscaped() {
+        val df = dataFrameOf("name", "int")("<Air France> (12)", 1)
+        val html = df.toHTML().toString()
+        html shouldContain "&#60;Air France&#62;"
+    }
+
+    @Test
+    fun unicodeEscapeSequencesAreEscaped() {
+        val df = dataFrameOf("content")("""Hello\nfrom \x and \y""")
+        val html = df.toHTML().toString()
+        html shouldContain "Hello&#92;nfrom &#92;x and &#92;y"
+    }
+
+    @Test
+    fun `long text is trimmed without escaping`() {
+        val df = dataFrameOf("text")("asdfkjasdlkjfhasljkddasdasdasdasdasdasdhf")
+        val html = df.toHTML().toString()
+        html shouldNotContain "\\\\"
+        html shouldNotContain "&#34;"
+    }
+
+    @Test
+    fun `non ascii text`() {
+        val value = "Шёл Шива по шоссе, сокрушая сущее"
+        val df = dataFrameOf("text")(value)
+        val script = df.toHTML().script
+        script shouldContain value.escapeHTML()
+    }
+
+    @Test
+    fun `empty row with nested empty row`() {
+        val df = dataFrameOf("a", "b", "c")(null, null, null)
+        val grouped = df
+            .group("a", "b").into("d")
+            .group("c", "d").into("e")[0]
+
+        val formatted = formatter.format(grouped, DefaultCellRenderer, DisplayConfiguration())
+        Jsoup.parse(formatted).text() shouldBe "{ }"
+
+        grouped.renderToString() shouldBe "{ }"
+    }
+
+    @Test
+    fun `render successfully`() {
+        dataFrameOf("a", "b")(listOf(1, 1), listOf(2, 4))
+            .group("a", "b")
+            .into("g")
+            .add("a") { 1 }
+            .toHTML()
+    }
+
+    @Test
+    fun `render URL`() {
+        val df = dataFrameOf("url")("https://api.github.com/orgs/JetBrains")
+        val html = df.parse().toHTML()
+        html.toString() shouldNotContain RenderedContent::class.simpleName!!
+    }
+
+    @Test
+    fun `render successfully 2`() {
+        val df = dataFrameOf("name", "parent", "type")("Boston (MA)", "123wazxdPag5", "Campus")
+            .move("parent").into { "parent"["id"] }
+            .group { all() }.into("Campus")
+        df.toHTML().print()
+    }
+
+    @Test
+    fun `render double with exponent`() {
+        val d = DecimalFormatSymbols.getInstance().decimalSeparator
+        listOf(
+            dataFrameOf("col")(1E27) to "1${d}000000e+27",
+            dataFrameOf("col")(1.123) to "1${d}123",
+            dataFrameOf("col")(1.0) to "1${d}0",
+        ).forEach { (df, rendered) ->
+            df.toHTML().script shouldContain rendered
+        }
+    }
+
+    @Test
+    fun `static rendering should be present`() {
+        val df = dataFrameOf("a", "b")(listOf(1, 1), listOf(2, 4))
+        val actualHtml = df.toHTML()
+
+        val body = actualHtml.body.lines().joinToString("") { it.trimStart() }
+
+        body shouldContain
+            """
+            <thead>
+            <tr>
+            <th class="bottomBorder" style="text-align:left">a</th>
+            <th class="bottomBorder" style="text-align:left">b</th>
+            </tr>
+            </thead>
+            <tbody>
+            <tr>
+            <td  style="vertical-align:top">[1, 1]</td>
+            <td  style="vertical-align:top">[2, 4]</td>
+            </tr>
+            </tbody>
+            </table>
+            """.trimIndent().replace("\n", "")
+    }
+
+    @Test
+    fun `max depth`() {
+        df.maxDepth() shouldBe 1
+        dfGroup.maxDepth() shouldBe 2
+        emptyDataFrame<Any>().maxDepth() shouldBe 0
+    }
+
+    @Test
+    fun `max width`() {
+        dfGroup.asColumnGroup("").maxWidth() shouldBe 8
+        dfGroup.name.maxWidth() shouldBe 4
+        dfGroup.name.firstName.maxWidth() shouldBe 3
+        dfGroup.name.lastName.maxWidth() shouldBe 1
+        dfGroup.name.firstName.secondName.maxWidth() shouldBe 1
+    }
+
+    @Test
+    fun `render array types correctly`() {
+        val df = dataFrameOf(
+            columnOf(1, null).named("a"),
+            columnOf(intArrayOf(1), intArrayOf(2)).named("b"),
+            // TODO https://github.com/Kotlin/dataframe/issues/679
+            // columnOf(arrayOf(1), arrayOf(2)).named("d"),
+            DataColumn.createValueColumn("c", listOf(arrayOf(1), arrayOf(2))),
+            columnOf(arrayOf(1, null), arrayOf(2, null)).named("d"),
+        )
+
+        val schema = df.schema()
+        val rendered = schema.toString()
+        rendered shouldBe "a: Int?\nb: IntArray\nc: Array<Int>\nd: Array<Int?>"
+    }
+}
diff --git a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/rendering/RenderingTestsBase.kt b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/rendering/RenderingTestsBase.kt
new file mode 100644
index 000000000..e20e01177
--- /dev/null
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/rendering/RenderingTestsBase.kt
@@ -0,0 +1,20 @@
+package org.jetbrains.kotlinx.dataframe.rendering
+
+import org.jetbrains.kotlinx.dataframe.api.dataFrameOf
+import org.jetbrains.kotlinx.dataframe.io.DisplayConfiguration
+import org.jetbrains.kotlinx.dataframe.io.formatter
+import org.jetbrains.kotlinx.dataframe.jupyter.DefaultCellRenderer
+import org.jsoup.Jsoup
+import org.jsoup.nodes.Element
+
+abstract class RenderingTestsBase {
+    protected fun rowOf(vararg pairs: Pair<String, Any?>) =
+        dataFrameOf(pairs.map { it.first }).withValues(pairs.map { it.second })[0]
+
+    protected fun Any?.truncate(limit: Int): String = format(limit).text()
+
+    protected fun Any?.tooltip(limit: Int): String? = format(limit).children().singleOrNull()?.attr("title")
+
+    protected fun Any?.format(limit: Int): Element =
+        Jsoup.parse(formatter.format(this, DefaultCellRenderer, DisplayConfiguration(cellContentLimit = limit))).body()
+}
diff --git a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/rendering/TooltipTests.kt b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/rendering/TooltipTests.kt
new file mode 100644
index 000000000..28caf2230
--- /dev/null
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/rendering/TooltipTests.kt
@@ -0,0 +1,25 @@
+package org.jetbrains.kotlinx.dataframe.rendering
+
+import io.kotest.matchers.shouldBe
+import org.junit.Test
+
+class TooltipTests : RenderingTestsBase() {
+
+    @Test
+    fun `long str`() {
+        "12345678".tooltip(5) shouldBe "12345678"
+    }
+
+    @Test
+    fun `short str`() {
+        "1234".tooltip(5) shouldBe null
+    }
+
+    @Test
+    fun row() {
+        val data = rowOf("name" to "Alice", "age" to 10)
+        val tooltip = "name: Alice\nage: 10"
+        data.tooltip(5) shouldBe tooltip
+        data.tooltip(15) shouldBe tooltip
+    }
+}
diff --git a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/rendering/TruncateTests.kt b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/rendering/TruncateTests.kt
new file mode 100644
index 000000000..89b5c81d0
--- /dev/null
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/rendering/TruncateTests.kt
@@ -0,0 +1,135 @@
+package org.jetbrains.kotlinx.dataframe.rendering
+
+import io.kotest.matchers.shouldBe
+import org.junit.Test
+
+class TruncateTests : RenderingTestsBase() {
+
+    @Test
+    fun `truncate str`() {
+        "123456789".truncate(5) shouldBe "12..."
+    }
+
+    @Test
+    fun `truncate str to ellipsis`() {
+        "123456789".truncate(3) shouldBe "..."
+    }
+
+    @Test
+    fun `no truncate`() {
+        "123".truncate(3) shouldBe "123"
+    }
+
+    @Test
+    fun truncateMany() {
+        listOf("1", "2", "34567890").truncate(15) shouldBe "[1, 2, 3456...]"
+    }
+
+    @Test
+    fun truncateMany2() {
+        listOf("1", "2345678", "9").truncate(15) shouldBe "[1, 2345678, 9]"
+    }
+
+    @Test
+    fun truncateMany7() {
+        listOf("1", "23456789", "0").truncate(15) shouldBe "[1, 2345..., 0]"
+    }
+
+    @Test
+    fun truncateMany3() {
+        listOf("1", "2345", "6789").truncate(15) shouldBe "[1, 2345, 6789]"
+    }
+
+    @Test
+    fun truncateMany4() {
+        listOf("1", "234567", "89012").truncate(15) shouldBe "[1, 2..., 8...]"
+    }
+
+    @Test
+    fun truncateMany5() {
+        listOf("1", "234567", "8901").truncate(15) shouldBe "[1, 2..., 8901]"
+    }
+
+    @Test
+    fun truncateMany6() {
+        listOf("1", "234567", "8", "9").truncate(15) shouldBe "[1, 23..., ...]"
+    }
+
+    @Test
+    fun truncateMany8() {
+        listOf("123456", "789", "0", "1").truncate(15) shouldBe "[123456, ...]"
+    }
+
+    @Test
+    fun truncateMany9() {
+        listOf("123456789", "789", "0", "1").truncate(15) shouldBe "[12345..., ...]"
+    }
+
+    @Test
+    fun truncateManyMany() {
+        listOf(1).truncate(3) shouldBe "[1]"
+        listOf(10).truncate(4) shouldBe "[10]"
+        listOf(1, 2).truncate(4) shouldBe "[..]"
+        listOf(100).truncate(4) shouldBe "[..]"
+        listOf(100).truncate(5) shouldBe "[100]"
+        listOf(1000).truncate(5) shouldBe "[...]"
+        listOf(1, 2).truncate(5) shouldBe "[...]"
+        listOf(1, 2).truncate(6) shouldBe "[1, 2]"
+    }
+
+    @Test
+    fun `run truncate row`() {
+        testTruncates(
+            rowOf("name" to "Alice", "age" to 10),
+            listOf(
+                "{..}",
+                "{...}",
+                "{ ...}",
+                "{ ... }",
+                "{ n..., a... }",
+                "{ na..., a... }",
+                "{ nam..., a... }",
+                "{ name..., a... }",
+                "{ name:..., a... }",
+                "{ name: ..., a... }",
+                "{ name: A..., a... }",
+                "{ name: Alice, a... }",
+                "{ name: Alice, ag... }",
+                "{ name: Alice, age... }",
+                "{ name: Alice, age: 10 }",
+            ),
+        )
+    }
+
+    private fun testTruncates(value: Any?, truncates: List<String>) {
+        val start = truncates[0].length
+        val end = truncates.last().length
+        val actual = (start..end).map { value.truncate(it) }
+        val expected = (start..end).map { len ->
+            truncates.indexOfFirst { it.length > len }.let {
+                if (it == -1) {
+                    truncates.last()
+                } else {
+                    truncates[it - 1]
+                }
+            }
+        }
+        actual shouldBe expected
+    }
+
+    @Test
+    fun `run truncate many`() {
+        val value = listOf("Alice", "Bob", "Billy")
+        testTruncates(
+            value,
+            listOf(
+                "[..]",
+                "[...]",
+                "[A..., ...]",
+                "[Alice, ...]",
+                "[Alice, Bob, B...]",
+                "[Alice, Bob, Billy]",
+            ),
+        )
+    }
+}
diff --git a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/rendering/html/Browsing.kt b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/rendering/html/Browsing.kt
new file mode 100644
index 000000000..8d6fb0f62
--- /dev/null
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/rendering/html/Browsing.kt
@@ -0,0 +1,42 @@
+package org.jetbrains.kotlinx.dataframe.rendering.html
+
+import org.jetbrains.kotlinx.dataframe.api.toDataFrame
+import org.junit.Ignore
+import org.junit.Test
+
+class Browsing {
+
+    @Ignore
+    @Test
+    fun test() {
+        data class Name(val firstName: String, val lastName: String?)
+
+        data class Score(val subject: String, val value: Int)
+
+        data class Student(val name: Name, val age: Int, val scores: List<Score>)
+
+        val students = listOf(
+            Student(Name("Alice", "Cooper"), 15, listOf(Score("math", 4), Score("biology", 3))),
+            Student(Name("Bob", "Marley"), 20, listOf(Score("music", 5))),
+            Student(Name("Null", null), 100, listOf(Score("nothing", 5))),
+            Student(Name("Antony", "Hover"), 20, listOf(Score("russian", 1))),
+            Student(Name("Sally", "Fever"), 20, listOf(Score("art", 4), Score("math", 4), Score("biology", 3))),
+        )
+
+        val df = students.toDataFrame {
+            "year of birth" from { 2021 - it.age }
+
+            properties(maxDepth = 1) {
+//                exclude(Score::subject) // `subject` property will be skipped from object graph traversal
+//                preserve<Name>() // `Name` objects will be stored as-is without transformation into DataFrame
+            }
+
+            "summary" {
+                "max score" from { it.scores.maxOf { it.value } }
+                "min score" from { it.scores.minOf { it.value } }
+            }
+        }
+
+        df.browse()
+    }
+}
diff --git a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/rendering/html/Utils.kt b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/rendering/html/Utils.kt
new file mode 100644
index 000000000..27a07d068
--- /dev/null
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/rendering/html/Utils.kt
@@ -0,0 +1,8 @@
+package org.jetbrains.kotlinx.dataframe.rendering.html
+
+import org.jetbrains.kotlinx.dataframe.AnyFrame
+import org.jetbrains.kotlinx.dataframe.io.toStandaloneHTML
+
+fun AnyFrame.browse() {
+    toStandaloneHTML().openInBrowser()
+}
diff --git a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/samples/api/Access.kt b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/samples/api/Access.kt
new file mode 100644
index 000000000..35eff4f49
--- /dev/null
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/samples/api/Access.kt
@@ -0,0 +1,1105 @@
+@file:Suppress("ktlint")
+
+package org.jetbrains.kotlinx.dataframe.samples.api
+
+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.column
+import org.jetbrains.kotlinx.dataframe.api.columnGroup
+import org.jetbrains.kotlinx.dataframe.api.columnOf
+import org.jetbrains.kotlinx.dataframe.api.countDistinct
+import org.jetbrains.kotlinx.dataframe.api.dataFrameOf
+import org.jetbrains.kotlinx.dataframe.api.distinct
+import org.jetbrains.kotlinx.dataframe.api.distinctBy
+import org.jetbrains.kotlinx.dataframe.api.drop
+import org.jetbrains.kotlinx.dataframe.api.dropLast
+import org.jetbrains.kotlinx.dataframe.api.dropNA
+import org.jetbrains.kotlinx.dataframe.api.dropNaNs
+import org.jetbrains.kotlinx.dataframe.api.dropNulls
+import org.jetbrains.kotlinx.dataframe.api.dropWhile
+import org.jetbrains.kotlinx.dataframe.api.fillNaNs
+import org.jetbrains.kotlinx.dataframe.api.filter
+import org.jetbrains.kotlinx.dataframe.api.filterBy
+import org.jetbrains.kotlinx.dataframe.api.first
+import org.jetbrains.kotlinx.dataframe.api.forEach
+import org.jetbrains.kotlinx.dataframe.api.gather
+import org.jetbrains.kotlinx.dataframe.api.getColumn
+import org.jetbrains.kotlinx.dataframe.api.getColumnGroup
+import org.jetbrains.kotlinx.dataframe.api.getColumns
+import org.jetbrains.kotlinx.dataframe.api.group
+import org.jetbrains.kotlinx.dataframe.api.groupBy
+import org.jetbrains.kotlinx.dataframe.api.into
+import org.jetbrains.kotlinx.dataframe.api.isColumnGroup
+import org.jetbrains.kotlinx.dataframe.api.map
+import org.jetbrains.kotlinx.dataframe.api.mapToRows
+import org.jetbrains.kotlinx.dataframe.api.maxBy
+import org.jetbrains.kotlinx.dataframe.api.maxByOrNull
+import org.jetbrains.kotlinx.dataframe.api.minBy
+import org.jetbrains.kotlinx.dataframe.api.minus
+import org.jetbrains.kotlinx.dataframe.api.move
+import org.jetbrains.kotlinx.dataframe.api.named
+import org.jetbrains.kotlinx.dataframe.api.notNull
+import org.jetbrains.kotlinx.dataframe.api.remove
+import org.jetbrains.kotlinx.dataframe.api.rows
+import org.jetbrains.kotlinx.dataframe.api.select
+import org.jetbrains.kotlinx.dataframe.api.single
+import org.jetbrains.kotlinx.dataframe.api.sortBy
+import org.jetbrains.kotlinx.dataframe.api.take
+import org.jetbrains.kotlinx.dataframe.api.takeLast
+import org.jetbrains.kotlinx.dataframe.api.takeWhile
+import org.jetbrains.kotlinx.dataframe.api.update
+import org.jetbrains.kotlinx.dataframe.api.values
+import org.jetbrains.kotlinx.dataframe.api.withZero
+import org.jetbrains.kotlinx.dataframe.api.xs
+import org.jetbrains.kotlinx.dataframe.explainer.TransformDataFrameExpressions
+import org.jetbrains.kotlinx.dataframe.get
+import org.junit.Test
+
+class Access : TestBase() {
+
+    @Test
+    @TransformDataFrameExpressions
+    fun getColumnByName_properties() {
+        // SampleStart
+        df.age
+        df.name.lastName
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun getColumnByName_accessors() {
+        // SampleStart
+        val age by column<Int>()
+        val name by columnGroup()
+        val lastName by name.column<String>()
+
+        df[age]
+        df[lastName]
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun getColumnByName_strings() {
+        // SampleStart
+        df["age"]
+        df["name"]["firstName"]
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun getColumn_properties() {
+        // SampleStart
+        df.getColumn { age }
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun getColumn_accessors() {
+        // SampleStart
+        val age by column<Int>()
+
+        df.getColumn { age }
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun getColumn_strings() {
+        // SampleStart
+        df.getColumn("age")
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun getColumnOrNull_properties() {
+        // SampleStart
+        df.getColumnOrNull { age }
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun getColumnOrNull_accessors() {
+        // SampleStart
+        val age by column<Int>()
+
+        df.getColumnOrNull(age)
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun getColumnOrNull_strings() {
+        // SampleStart
+        df.getColumnOrNull("age")
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun getColumns_properties() {
+        // SampleStart
+        df.getColumns { age and name }
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun getColumns_accessors() {
+        // SampleStart
+        val age by column<Int>()
+        val name by columnGroup()
+
+        df.getColumns { age and name }
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun getColumns_strings() {
+        // SampleStart
+        df.getColumns("age", "name")
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun getColumnGroup_properties() {
+        // SampleStart
+        df.getColumnGroup { name }
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun getColumnGroup_accessors() {
+        // SampleStart
+        val name by columnGroup()
+
+        df.getColumnGroup(name)
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun getColumnGroup_strings() {
+        // SampleStart
+        df.getColumnGroup("name")
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun getColumnByIndex() {
+        // SampleStart
+        df.getColumn(2)
+        df.getColumnGroup(0).getColumn(1)
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun getRowByIndex() {
+        // SampleStart
+        df[2]
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun getRowByCondition_properties() {
+        // SampleStart
+        df.single { age == 45 }
+        df.first { weight != null }
+        df.minBy { age }
+        df.maxBy { name.firstName.length }
+        df.maxByOrNull { weight }
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun getRowByCondition_accessors() {
+        // SampleStart
+        val age by column<Int>()
+        val weight by column<Int?>()
+        val name by columnGroup()
+        val firstName by name.column<String>()
+
+        df.single { age() == 45 }
+        df.first { weight() != null }
+        df.minBy(age)
+        df.maxBy { firstName().length }
+        df.maxByOrNull { weight() }
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun getRowByCondition_strings() {
+        // SampleStart
+        df.single { "age"<Int>() == 45 }
+        df.first { it["weight"] != null }
+        df.minBy("weight")
+        df.maxBy { "name"["firstName"]<String>().length }
+        df.maxByOrNull("weight")
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun getCell_strings() {
+        // SampleStart
+        df["age"][1]
+        df[1]["age"]
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun getCell_properties() {
+        // SampleStart
+        df.age[1]
+        df[1].age
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun getCell_accessors() {
+        // SampleStart
+        val age by column<String>()
+
+        df[age][1]
+        df[1][age]
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun getColumnsByName_properties() {
+        // SampleStart
+        df[df.age, df.weight]
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun getColumnsByName_accessors() {
+        // SampleStart
+        val age by column<Int>()
+        val weight by column<Int?>()
+
+        df[age, weight]
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun getColumnsByName_strings() {
+        // SampleStart
+        df["age", "weight"]
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun select_properties() {
+        // SampleStart
+        df.select { age and weight }
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun select_accessors() {
+        // SampleStart
+        val age by column<Int>()
+        val weight by column<Int?>()
+
+        df.select { age and weight }
+        df.select(age, weight)
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun select_strings() {
+        // SampleStart
+        df.select { "age" and "weight" }
+        df.select("age", "weight")
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun getSeveralRowsByIndices() {
+        // SampleStart
+        df[0, 3, 4]
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun getSeveralRowsByRanges() {
+        // SampleStart
+        df[1..2]
+        df[0..2, 4..5]
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun getRowsColumns() {
+        // SampleStart
+        df.columns() // List<DataColumn>
+        df.rows() // Iterable<DataRow>
+        df.values() // Sequence<Any?>
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun take() {
+        // SampleStart
+        df.take(5)
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun takeLast() {
+        // SampleStart
+        df.takeLast(5)
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun takeWhile() {
+        // SampleStart
+        df.takeWhile { isHappy }
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun drop() {
+        // SampleStart
+        df.drop(5)
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun dropLast() {
+        // SampleStart
+        df.dropLast() // default 1
+        df.dropLast(5)
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun dropWhile() {
+        // SampleStart
+        df.dropWhile { !isHappy }
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun filter_properties() {
+        // SampleStart
+        df.filter { age > 18 && name.firstName.startsWith("A") }
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun filter_accessors() {
+        // SampleStart
+        val age by column<Int>()
+        val name by columnGroup()
+        val firstName by name.column<String>()
+
+        df.filter { age() > 18 && firstName().startsWith("A") }
+        // or
+        df.filter { it[age] > 18 && it[firstName].startsWith("A") }
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun filter_strings() {
+        // SampleStart
+        df.filter { "age"<Int>() > 18 && "name"["firstName"]<String>().startsWith("A") }
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun filterBy_properties() {
+        // SampleStart
+        df.filterBy { isHappy }
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun filterBy_accessors() {
+        // SampleStart
+        val isHappy by column<Boolean>()
+        df.filterBy { isHappy }
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun filterBy_strings() {
+        // SampleStart
+        df.filterBy("isHappy")
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun dropWhere_properties() {
+        // SampleStart
+        df.drop { weight == null || city == null }
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun dropWhere_accessors() {
+        // SampleStart
+        val name by columnGroup()
+        val weight by column<Int?>()
+        val city by column<String?>()
+
+        df.drop { weight() == null || city() == null }
+        // or
+        df.drop { it[weight] == null || it[city] == null }
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun dropWhere_strings() {
+        // SampleStart
+        df.drop { it["weight"] == null || it["city"] == null }
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun dropNulls() {
+        // SampleStart
+        df.dropNulls() // remove rows with null value in any column
+        df.dropNulls(whereAllNull = true) // remove rows with null values in all columns
+        df.dropNulls { city } // remove rows with null value in 'city' column
+        df.dropNulls { city and weight } // remove rows with null value in 'city' OR 'weight' columns
+        df.dropNulls(whereAllNull = true) { city and weight } // remove rows with null value in 'city' AND 'weight' columns
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun dropNaNs() {
+        // SampleStart
+        df.dropNaNs() // remove rows containing NaN in any column
+        df.dropNaNs(whereAllNaN = true) // remove rows with NaN in all columns
+        df.dropNaNs { weight } // remove rows where 'weight' is NaN
+        df.dropNaNs { age and weight } // remove rows where either 'age' or 'weight' is NaN
+        df.dropNaNs(whereAllNaN = true) { age and weight } // remove rows where both 'age' and 'weight' are NaN
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun dropNA() {
+        // SampleStart
+        df.dropNA() // remove rows containing null or NaN in any column
+        df.dropNA(whereAllNA = true) // remove rows with null or NaN in all columns
+        df.dropNA { weight } // remove rows where 'weight' is null or NaN
+        df.dropNA { age and weight } // remove rows where either 'age' or 'weight' is null or NaN
+        df.dropNA(whereAllNA = true) { age and weight } // remove rows where both 'age' and 'weight' are null or NaN
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun byColumn_strings() {
+        // SampleStart
+        df["name"][0]
+        df["name", "age"][3, 5, 6]
+        // SampleEnd
+        // TODO: df["age"][2..4]
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun byColumn_accessors() {
+        // SampleStart
+        val name by column<String>()
+        val age by column<Int>()
+        df[name][0]
+        df[name, age][3, 5, 6]
+        // SampleEnd
+        // TODO: df[age][2..4]
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun byColumn_properties() {
+        // SampleStart
+        df.name[0]
+        df.select { name and age }[3, 5, 6]
+        df.age[2..4]
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun byRow_strings() {
+        // SampleStart
+        df[0]["name"]
+        df[3, 5, 6]["name", "age"]
+        df[3..5]["age"]
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun byRow_accessors() {
+        // SampleStart
+        val name by column<String>()
+        val age by column<Int>()
+        df[0][name]
+        df[3, 5, 6][name, age]
+        df[3..5][age]
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun byRow_properties() {
+        // SampleStart
+        df[0].name
+        df[3, 5, 6].select { name and age }
+        df[3..5].age
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun namedAndRenameCol() {
+        // SampleStart
+        val unnamedCol = columnOf("Alice", "Bob")
+        val colRename = unnamedCol.rename("name")
+        val colNamed = columnOf("Alice", "Bob") named "name"
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun namedColumnWithoutValues() {
+        // SampleStart
+        val name by column<String>()
+        val col = column<String>("name")
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun colRefForTypedAccess() {
+        val df = dataFrameOf("name")("Alice", "Bob")
+        val name by column<String>()
+        val col = column<String>("name")
+        // SampleStart
+        df.filter { it[name].startsWith("A") }
+        df.sortBy { col }
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun iterableApi() {
+        // SampleStart
+        df.forEach { println(it) }
+        df.take(5)
+        df.drop(2)
+        df.chunked(10)
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun distinct() {
+        // SampleStart
+        df.distinct()
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun distinctColumns_properties() {
+        // SampleStart
+        df.distinct { age and name }
+        // same as
+        df.select { age and name }.distinct()
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun distinctColumns_accessors() {
+        // SampleStart
+        val age by column<Int>()
+        val name by columnGroup()
+        df.distinct { age and name }
+        // same as
+        df.select { age and name }.distinct()
+        // 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_accessors() {
+        // SampleStart
+        val age by column<Int>()
+        val name by columnGroup()
+        df.countDistinct { age and name }
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun countDistinctColumns_strings() {
+        // SampleStart
+        df.countDistinct("age", "name")
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun distinctColumns_strings() {
+        // SampleStart
+        df.distinct("age", "name")
+        // same as
+        df.select("age", "name").distinct()
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun distinctBy_properties() {
+        // SampleStart
+        df.distinctBy { age and name }
+        // same as
+        df.groupBy { age and name }.mapToRows { group.first() }
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun distinctBy_accessors() {
+        // SampleStart
+        val age by column<Int>()
+        val name by columnGroup()
+        val firstName by name.column<String>()
+
+        df.distinctBy { age and name }
+        // same as
+        df.groupBy { age and name }.mapToRows { group.first() }
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun distinctBy_strings() {
+        // SampleStart
+        df.distinctBy("age", "name")
+        // same as
+        df.groupBy("age", "name").mapToRows { group.first() }
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun columnSelectorsUsages() {
+        // SampleStart
+        df.select { age and name }
+        df.fillNaNs { colsAtAnyDepth().colsOf<Double>() }.withZero()
+        df.remove { cols { it.hasNulls() } }
+        df.group { cols { it.data != name } }.into { "nameless" }
+        df.update { city }.notNull { it.lowercase() }
+        df.gather { colsOf<Number>() }.into("key", "value")
+        df.move { name.firstName and name.lastName }.after { city }
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun columnSelectors_properties() {
+        // SampleStart
+        // by column name
+        df.select { it.name }
+        df.select { name }
+
+        // by column path
+        df.select { name.firstName }
+
+        // with a new name
+        df.select { name named "Full Name" }
+
+        // converted
+        df.select { name.firstName.map { it.lowercase() } }
+
+        // column arithmetics
+        df.select { 2021 - age }
+
+        // two columns
+        df.select { name and age }
+
+        // range of columns
+        df.select { name..age }
+
+        // all columns of ColumnGroup
+        df.select { name.allCols() }
+
+        // traversal of columns at any depth from here excluding ColumnGroups
+        df.select { name.colsAtAnyDepth { !it.isColumnGroup() } }
+
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun columnSelectors_accessors() {
+        // SampleStart
+        // by column name
+        val name by columnGroup()
+        df.select { it[name] }
+        df.select { name }
+
+        // by column path
+        val firstName by name.column<String>()
+        df.select { firstName }
+
+        // with a new name
+        df.select { name named "Full Name" }
+
+        // converted
+        df.select { firstName.map { it.lowercase() } }
+
+        // column arithmetics
+        val age by column<Int>()
+        df.select { 2021 - age }
+
+        // two columns
+        df.select { name and age }
+
+        // range of columns
+        df.select { name..age }
+
+        // all columns of ColumnGroup
+        df.select { name.allCols() }
+
+        // traversal of columns at any depth from here excluding ColumnGroups
+        df.select { name.colsAtAnyDepth { !it.isColumnGroup() } }
+        // SampleEnd
+    }
+
+    @Test
+    fun columnSelectors_kproperties() {
+        // SampleStart
+        // by column name
+        df.select { it[Person::name] }
+        df.select { (Person::name)() }
+        df.select { col(Person::name) }
+
+        // by column path
+        df.select { it[Person::name][Name::firstName] }
+        df.select { Person::name[Name::firstName] }
+
+        // with a new name
+        df.select { Person::name named "Full Name" }
+
+        // converted
+        df.select { Person::name[Name::firstName].map { it.lowercase() } }
+
+        // column arithmetics
+        df.select { 2021 - (Person::age)() }
+
+        // two columns
+        df.select { Person::name and Person::age }
+
+        // range of columns
+        df.select { Person::name..Person::age }
+
+        // all columns of ColumnGroup
+        df.select { Person::name.allCols() }
+
+        // traversal of columns at any depth from here excluding ColumnGroups
+        df.select { Person::name.colsAtAnyDepth { !it.isColumnGroup() } }
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun columnSelectors_strings() {
+        // SampleStart
+        // by column name
+        df.select { it["name"] }
+
+        // by column path
+        df.select { it["name"]["firstName"] }
+        df.select { "name"["firstName"] }
+
+        // with a new name
+        df.select { "name" named "Full Name" }
+
+        // converted
+        df.select { "name"["firstName"]<String>().map { it.uppercase() } }
+
+        // column arithmetics
+        df.select { 2021 - "age"<Int>() }
+
+        // two columns
+        df.select { "name" and "age" }
+
+        // by range of names
+        df.select { "name".."age" }
+
+        // all columns of ColumnGroup
+        df.select { "name".allCols() }
+
+        // traversal of columns at any depth from here excluding ColumnGroups
+        df.select { "name".colsAtAnyDepth { !it.isColumnGroup() } }
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun columnsSelectorByIndices() {
+        // SampleStart
+        // by index
+        df.select { col(2) }
+
+        // by several indices
+        df.select { cols(0, 1, 3) }
+
+        // by range of indices
+        df.select { cols(1..4) }
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun columnSelectorsMisc() {
+        val df = df.add { "year" from { 0 } }
+        // SampleStart
+        // by condition
+        df.select { cols { it.name().startsWith("year") } }
+        df.select { nameStartsWith("year") }
+
+        // by type
+        df.select { colsOf<String>() }
+
+        // by type with condition
+        df.select { colsOf<String?> { it.countDistinct() > 5 } }
+
+        // all top-level columns
+        df.select { all() }
+
+        // first/last n columns
+        df.select { take(2) }
+        df.select { takeLast(2) }
+
+        // all except first/last n columns
+        df.select { drop(2) }
+        df.select { dropLast(2) }
+
+        // find the first column satisfying the condition
+        df.select { first { it.name.startsWith("year") } }
+
+        // find the last column inside a column group satisfying the condition
+        df.select {
+            colGroup("name").lastCol { it.name().endsWith("Name") }
+        }
+
+        // find the single column inside a column group satisfying the condition
+        df.select {
+            Person::name.singleCol { it.name().startsWith("first") }
+        }
+
+        // traversal of columns at any depth from here excluding ColumnGroups
+        df.select { colsAtAnyDepth { !it.isColumnGroup() } }
+
+        // traversal of columns at any depth from here including ColumnGroups
+        df.select { colsAtAnyDepth() }
+
+        // traversal of columns at any depth with condition
+        df.select { colsAtAnyDepth { it.name().contains(":") } }
+
+        // traversal of columns at any depth to find columns of given type
+        df.select { colsAtAnyDepth().colsOf<String>() }
+
+        // all columns except given column set
+        df.select { allExcept { colsOf<String>() } }
+
+        // union of column sets
+        df.select { take(2) and col(3) }
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun columnSelectorsModifySet() {
+        // SampleStart
+        // first/last n value- and frame columns in column set
+        df.select { colsAtAnyDepth { !it.isColumnGroup() }.take(3) }
+        df.select { colsAtAnyDepth { !it.isColumnGroup() }.takeLast(3) }
+
+        // all except first/last n value- and frame columns in column set
+        df.select { colsAtAnyDepth { !it.isColumnGroup() }.drop(3) }
+        df.select { colsAtAnyDepth { !it.isColumnGroup() }.dropLast(3) }
+
+        // filter column set by condition
+        df.select { colsAtAnyDepth { !it.isColumnGroup() }.filter { it.name().startsWith("year") } }
+
+        // exclude columns from column set
+        df.select { colsAtAnyDepth { !it.isColumnGroup() }.except { age } }
+
+        // keep only unique columns
+        df.select { (colsOf<Int>() and age).distinct() }
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun forRows_properties() {
+        // SampleStart
+        for (row in df) {
+            println(row.age)
+        }
+
+        df.forEach {
+            println(it.age)
+        }
+
+        df.rows().forEach {
+            println(it.age)
+        }
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun forRows_accessors() {
+        // SampleStart
+        val age by column<Int>()
+
+        for (row in df) {
+            println(row[age])
+        }
+
+        df.forEach {
+            println(it[age])
+        }
+
+        df.rows().forEach {
+            println(it[age])
+        }
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun forRows_strings() {
+        // SampleStart
+        for (row in df) {
+            println(row["age"])
+        }
+
+        df.forEach {
+            println(it["age"])
+        }
+
+        df.rows().forEach {
+            println(it["age"])
+        }
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun forColumn() {
+        // SampleStart
+        df.columns().forEach {
+            println(it.name())
+        }
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun forCells() {
+        // SampleStart
+        // from top to bottom, then from left to right
+        df.values().forEach {
+            println(it)
+        }
+
+        // from left to right, then from top to bottom
+        df.values(byRows = true).forEach {
+            println(it)
+        }
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun xs() {
+        // SampleStart
+        df.xs("Charlie", "Chaplin")
+
+        df.xs("Moscow", true) { city and isHappy }
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun values() {
+        // SampleStart
+        df.values()
+        df.values(byRows = true)
+        df.values { age and weight }
+        // SampleEnd
+    }
+}
diff --git a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/samples/api/Analyze.kt b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/samples/api/Analyze.kt
new file mode 100644
index 000000000..bec7a2def
--- /dev/null
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/samples/api/Analyze.kt
@@ -0,0 +1,1334 @@
+@file:Suppress("ktlint")
+
+package org.jetbrains.kotlinx.dataframe.samples.api
+
+import org.jetbrains.kotlinx.dataframe.api.aggregate
+import org.jetbrains.kotlinx.dataframe.api.asComparable
+import org.jetbrains.kotlinx.dataframe.api.asGroupBy
+import org.jetbrains.kotlinx.dataframe.api.asNumbers
+import org.jetbrains.kotlinx.dataframe.api.colsOf
+import org.jetbrains.kotlinx.dataframe.api.column
+import org.jetbrains.kotlinx.dataframe.api.columnGroup
+import org.jetbrains.kotlinx.dataframe.api.columnOf
+import org.jetbrains.kotlinx.dataframe.api.concat
+import org.jetbrains.kotlinx.dataframe.api.count
+import org.jetbrains.kotlinx.dataframe.api.cumSum
+import org.jetbrains.kotlinx.dataframe.api.dataFrameOf
+import org.jetbrains.kotlinx.dataframe.api.describe
+import org.jetbrains.kotlinx.dataframe.api.div
+import org.jetbrains.kotlinx.dataframe.api.expr
+import org.jetbrains.kotlinx.dataframe.api.frames
+import org.jetbrains.kotlinx.dataframe.api.groupBy
+import org.jetbrains.kotlinx.dataframe.api.groupByOther
+import org.jetbrains.kotlinx.dataframe.api.head
+import org.jetbrains.kotlinx.dataframe.api.indices
+import org.jetbrains.kotlinx.dataframe.api.length
+import org.jetbrains.kotlinx.dataframe.api.matches
+import org.jetbrains.kotlinx.dataframe.api.max
+import org.jetbrains.kotlinx.dataframe.api.maxBy
+import org.jetbrains.kotlinx.dataframe.api.maxByOrNull
+import org.jetbrains.kotlinx.dataframe.api.maxFor
+import org.jetbrains.kotlinx.dataframe.api.maxOf
+import org.jetbrains.kotlinx.dataframe.api.maxOrNull
+import org.jetbrains.kotlinx.dataframe.api.mean
+import org.jetbrains.kotlinx.dataframe.api.meanFor
+import org.jetbrains.kotlinx.dataframe.api.meanOf
+import org.jetbrains.kotlinx.dataframe.api.median
+import org.jetbrains.kotlinx.dataframe.api.medianFor
+import org.jetbrains.kotlinx.dataframe.api.medianOf
+import org.jetbrains.kotlinx.dataframe.api.min
+import org.jetbrains.kotlinx.dataframe.api.minBy
+import org.jetbrains.kotlinx.dataframe.api.minFor
+import org.jetbrains.kotlinx.dataframe.api.minOf
+import org.jetbrains.kotlinx.dataframe.api.minOrNull
+import org.jetbrains.kotlinx.dataframe.api.pivot
+import org.jetbrains.kotlinx.dataframe.api.pivotCounts
+import org.jetbrains.kotlinx.dataframe.api.pivotMatches
+import org.jetbrains.kotlinx.dataframe.api.schema
+import org.jetbrains.kotlinx.dataframe.api.std
+import org.jetbrains.kotlinx.dataframe.api.stdFor
+import org.jetbrains.kotlinx.dataframe.api.stdOf
+import org.jetbrains.kotlinx.dataframe.api.sum
+import org.jetbrains.kotlinx.dataframe.api.sumFor
+import org.jetbrains.kotlinx.dataframe.api.sumOf
+import org.jetbrains.kotlinx.dataframe.api.toDataFrame
+import org.jetbrains.kotlinx.dataframe.api.valueCounts
+import org.jetbrains.kotlinx.dataframe.api.values
+import org.jetbrains.kotlinx.dataframe.explainer.TransformDataFrameExpressions
+import org.junit.Test
+import kotlin.math.ln
+
+class Analyze : TestBase() {
+
+    @Test
+    @TransformDataFrameExpressions
+    fun basicInfo() {
+        // SampleStart
+        df.count() // same as df.rowsCount()
+        df.indices() // 0 until count()
+        df.columnsCount()
+        df.columnNames()
+        df.head()
+        df.schema()
+        df.describe()
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun head() {
+        // SampleStart
+        df.head(3)
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun schema() {
+        // SampleStart
+        df.schema()
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun schemaGroupBy() {
+        // SampleStart
+        df.groupBy { city }.schema()
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun describe() {
+        // SampleStart
+        df.describe()
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun describeColumns_properties() {
+        // SampleStart
+        df.describe { age and name.allCols() }
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun describeColumns_accessors() {
+        // SampleStart
+        val age by column<Int>()
+        val name by columnGroup()
+
+        df.describe { age and name.allCols() }
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun describeColumns_strings() {
+        // SampleStart
+        df.describe { "age" and "name".allCols() }
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun countCondition() {
+        // SampleStart
+        df.count { age > 15 }
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun count() {
+        // SampleStart
+        df.count()
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun countAggregation() {
+        // SampleStart
+        df.groupBy { city }.count()
+        df.pivot { city }.count { age > 18 }
+        df.pivot { name.firstName }.groupBy { name.lastName }.count()
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun sumAggregations() {
+        // SampleStart
+        df.age.sum()
+        df.groupBy { city }.sum()
+        df.pivot { city }.sum()
+        df.pivot { city }.groupBy { name.lastName }.sum()
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun statisticModes() {
+        // SampleStart
+        df.sum() // sum of values per every numeric column
+        df.sum { age and weight } // sum of all values in `age` and `weight`
+        df.sumFor { age and weight } // sum of values per `age` and `weight` separately
+        df.sumOf { (weight ?: 0) / age } // sum of expression evaluated for every row
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun minmaxModes() {
+        // SampleStart
+        df.min() // min of values per every comparable column
+        df.min { age and weight } // min of all values in `age` and `weight`
+        df.minFor { age and weight } // min of values per `age` and `weight` separately
+        df.minOf { (weight ?: 0) / age } // min of expression evaluated for every row
+        df.minBy { age } // DataRow with minimal `age`
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun minmaxAggregations() {
+        // SampleStart
+        df.min()
+        df.age.min()
+        df.groupBy { city }.min()
+        df.pivot { city }.min()
+        df.pivot { city }.groupBy { name.lastName }.min()
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun medianModes() {
+        // SampleStart
+        df.median() // median of values per every comparable column
+        df.median { age and weight } // median of all values in `age` and `weight`
+        df.medianFor { age and weight } // median of values per `age` and `weight` separately
+        df.medianOf { (weight ?: 0) / age } // median of expression evaluated for every row
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun medianAggregations() {
+        // SampleStart
+        df.median()
+        df.age.median()
+        df.groupBy { city }.median()
+        df.pivot { city }.median()
+        df.pivot { city }.groupBy { name.lastName }.median()
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun meanModes() {
+        // SampleStart
+        df.mean() // mean of values per every numeric column
+        df.mean(skipNA = true) { age and weight } // mean of all values in `age` and `weight`, skips NA
+        df.meanFor(skipNA = true) { age and weight } // mean of values per `age` and `weight` separately, skips NA
+        df.meanOf { (weight ?: 0) / age } // median of expression evaluated for every row
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun meanAggregations() {
+        // SampleStart
+        df.mean()
+        df.age.mean()
+        df.groupBy { city }.mean()
+        df.pivot { city }.mean()
+        df.pivot { city }.groupBy { name.lastName }.mean()
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun stdModes() {
+        // SampleStart
+        df.std() // std of values per every numeric column
+        df.std { age and weight } // std of all values in `age` and `weight`
+        df.stdFor { age and weight } // std of values per `age` and `weight` separately, skips NA
+        df.stdOf { (weight ?: 0) / age } // std of expression evaluated for every row
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun stdAggregations() {
+        // SampleStart
+        df.std()
+        df.age.std()
+        df.groupBy { city }.std()
+        df.pivot { city }.std()
+        df.pivot { city }.groupBy { name.lastName }.std()
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun meanAggregationsSkipNA() {
+        // SampleStart
+        df.mean(skipNA = true)
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun statisticAggregations() {
+        // SampleStart
+        df.mean()
+        df.age.sum()
+        df.groupBy { city }.mean()
+        df.pivot { city }.median()
+        df.pivot { city }.groupBy { name.lastName }.std()
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun statisticGroupBySingle() {
+        // SampleStart
+        df.groupBy { city }.mean { age } // [`city`, `mean`]
+        df.groupBy { city }.meanOf { age / 2 } // [`city`, `mean`]
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun statisticGroupBySingleNamed() {
+        // SampleStart
+        df.groupBy { city }.mean("mean age") { age } // [`city`, `mean age`]
+        df.groupBy { city }.meanOf("custom") { age / 2 } // [`city`, `custom`]
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun statisticGroupByMany() {
+        // SampleStart
+        df.groupBy { city }.meanFor { age and weight } // [`city`, `age`, `weight`]
+        df.groupBy { city }.mean() // [`city`, `age`, `weight`, ...]
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun statisticPivotSingle_properties() {
+        // SampleStart
+        df.groupBy { city }.pivot { name.lastName }.mean { age }
+        df.groupBy { city }.pivot { name.lastName }.meanOf { age / 2.0 }
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun statisticPivotSingle_accessors() {
+        // SampleStart
+        val city by column<String?>()
+        val age by column<Int>()
+        val name by columnGroup()
+        val lastName by name.column<String>()
+
+        df.groupBy { city }.pivot { lastName }.mean { age }
+        df.groupBy { city }.pivot { lastName }.meanOf { age() / 2.0 }
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun statisticPivotSingle_strings() {
+        // SampleStart
+        df.groupBy("city").pivot { "name"["lastName"] }.mean("age")
+        df.groupBy("city").pivot { "name"["lastName"] }.meanOf { "age"<Int>() / 2.0 }
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun statisticPivotMany() {
+        // SampleStart
+        df.groupBy { city }.pivot { name.lastName }.meanFor { age and weight }
+        df.groupBy { city }.pivot { name.lastName }.mean()
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun statisticPivotManySeparate() {
+        // SampleStart
+        df.groupBy { city }.pivot { name.lastName }.meanFor(separate = true) { age and weight }
+        df.groupBy { city }.pivot { name.lastName }.mean(separate = true)
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun columnStats_properties() {
+        // SampleStart
+        df.sum { weight }
+        df.min { age }
+        df.mean { age }
+        df.median { age }
+
+        df.weight.sum()
+        df.age.max()
+        df.age.mean()
+        df.age.median()
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun columnStats_accessors() {
+        // SampleStart
+        val weight by column<Int?>()
+        val age by column<Int>()
+
+        df.sum { weight }
+        df.min { age }
+        df.mean { age }
+        df.median { age }
+
+        df.sum(weight)
+        df.min(age)
+        df.mean(age)
+        df.median(age)
+
+        df[weight].sum()
+        df[age].mean()
+        df[age].min()
+        df[age].median()
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun columnStats_strings() {
+        // SampleStart
+        df.sum("weight")
+        df.min("age")
+        df.mean("age")
+        df.median("age")
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun multipleColumnsStat_properties() {
+        // SampleStart
+        df.min { colsOf<Int>() }
+        df.max { name.firstName and name.lastName }
+        df.sum { age and weight }
+        df.mean { cols(1, 3).asNumbers() }
+        df.median { name.cols().asComparable() }
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun multipleColumnsStat_accessors() {
+        // SampleStart
+        val name by columnGroup()
+        val firstName by name.column<String>()
+        val lastName by name.column<String>()
+        val age by column<Int>()
+        val weight by column<Int?>()
+
+        df.min { colsOf<Int>() }
+
+        df.max { firstName and lastName }
+        // or
+        df.max(firstName, lastName)
+
+        df.sum { age and weight }
+        // or
+        df.sum(age, weight)
+
+        df.mean { cols(1, 3).asNumbers() }
+        df.median { name.cols().asComparable() }
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun multipleColumnsStat_strings() {
+        // SampleStart
+
+        df.min { colsOf<Int>() }
+
+        df.max { "name"["firstName"].asComparable() and "name"["lastName"].asComparable() }
+
+        df.sum("age", "weight")
+        // or
+        df.sum { "age"<Int>() and "weight"<Int?>() }
+
+        df.mean { cols(1, 3).asNumbers() }
+        df.median { name.cols().asComparable() }
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun columnsFor_properties() {
+        // SampleStart
+        df.minFor { colsOf<Int>() }
+        df.maxFor { name.firstName and name.lastName }
+        df.sumFor { age and weight }
+        df.meanFor { cols(1, 3).asNumbers() }
+        df.medianFor { name.cols().asComparable() }
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun columnsFor_aсcessors() {
+        // SampleStart
+        val name by columnGroup()
+        val firstName by name.column<String>()
+        val lastName by name.column<String>()
+        val age by column<Int>()
+        val weight by column<Int?>()
+
+        df.minFor { colsOf<Int>() }
+
+        df.maxFor { firstName and lastName }
+        // or
+        df.maxFor(firstName, lastName)
+
+        df.sumFor { age and weight }
+        // or
+        df.sum(age, weight)
+
+        df.mean { cols(1, 3).asNumbers() }
+        df.median { name.cols().asComparable() }
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun columnsFor_strings() {
+        // SampleStart
+        df.minFor { colsOf<Int>() }
+        df.maxFor { "name"["firstName"].asComparable() and "name"["lastName"].asComparable() }
+
+        df.sumFor("age", "weight")
+        // or
+        df.sumFor { "age"<Int>() and "weight"<Int?>() }
+
+        df.meanFor { cols(1, 3).asNumbers() }
+        df.medianFor { name.cols().asComparable() }
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun ofExpressions_properties() {
+        // SampleStart
+        df.minOf { 2021 - age }
+        df.maxOf { name.firstName.length + name.lastName.length }
+        df.sumOf { weight?.let { it - 50 } }
+        df.meanOf { ln(age.toDouble()) }
+        df.medianOf { city?.length }
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun ofExpressions_accessors() {
+        // SampleStart
+        val name by columnGroup()
+        val firstName by name.column<String>()
+        val lastName by name.column<String>()
+        val age by column<Int>()
+        val weight by column<Int?>()
+        val city by column<String?>()
+
+        df.minOf { 2021 - age() }
+        df.maxOf { firstName().length + lastName().length }
+        df.sumOf { weight()?.let { it - 50 } }
+        df.meanOf { ln(age().toDouble()) }
+        df.medianOf { city()?.length }
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun ofExpressions_strings() {
+        // SampleStart
+        df.minOf { 2021 - "age"<Int>() }
+        df.maxOf { "name"["firstName"]<String>().length + "name"["lastName"]<String>().length }
+        df.sumOf { "weight"<Int?>()?.let { it - 50 } }
+        df.meanOf { ln("age"<Int>().toDouble()) }
+        df.medianOf { "city"<String?>()?.length }
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun groupBy_properties() {
+        // SampleStart
+        df.groupBy { name }
+        df.groupBy { city and name.lastName }
+        df.groupBy { age / 10 named "ageDecade" }
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun groupBy_accessors() {
+        // SampleStart
+        val name by columnGroup()
+        val lastName by name.column<String>()
+        val firstName by name.column<String>()
+        val age by column<Int>()
+        val city by column<String?>()
+
+        df.groupBy { name }
+        // or
+        df.groupBy(name)
+
+        df.groupBy { city and lastName }
+        // or
+        df.groupBy(city, lastName)
+
+        df.groupBy { age / 10 named "ageDecade" }
+
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun groupBy_strings() {
+        // SampleStart
+        df.groupBy("name")
+        df.groupBy { "city" and "name"["lastName"] }
+        df.groupBy { "age"<Int>() / 10 named "ageDecade" }
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun groupByExpr_properties() {
+        // SampleStart
+        df.groupBy { expr { name.firstName.length + name.lastName.length } named "nameLength" }
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun groupByExpr_accessors() {
+        // SampleStart
+        val name by columnGroup()
+        val lastName by name.column<String>()
+        val firstName by name.column<String>()
+
+        df.groupBy { expr { firstName().length + lastName().length } named "nameLength" }
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun groupByExpr_strings() {
+        // SampleStart
+        df.groupBy { expr { "name"["firstName"]<String>().length + "name"["lastName"]<String>().length } named "nameLength" }
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun groupByMoveToTop() {
+        // SampleStart
+        df.groupBy(moveToTop = true) { name.lastName }
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun groupByMoveToTopFalse() {
+        // SampleStart
+        df.groupBy(moveToTop = false) { name.lastName }
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun dataFrameToGroupBy() {
+        // SampleStart
+        val key by columnOf(1, 2) // create int column with name "key"
+        val data by columnOf(df[0..3], df[4..6]) // create frame column with name "data"
+        val df = dataFrameOf(key, data) // create dataframe with two columns
+
+        df.asGroupBy { data } // convert dataframe to GroupBy by interpreting 'data' column as groups
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun groupByToFrame() {
+        // SampleStart
+        df.groupBy { city }.toDataFrame()
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun groupByAggregations_properties() {
+        // SampleStart
+        df.groupBy { city }.aggregate {
+            count() into "total"
+            count { age > 18 } into "adults"
+            median { age } into "median age"
+            min { age } into "min age"
+            maxBy { age }.name into "oldest"
+        }
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun groupByAggregations_accessors() {
+        // SampleStart
+        val city by column<String?>()
+        val age by column<Int>()
+        val name by columnGroup()
+
+        df.groupBy { city }.aggregate {
+            count() into "total"
+            count { age() > 18 } into "adults"
+            median { age } into "median age"
+            min { age } into "min age"
+            maxBy { age() }[name] into "name of oldest"
+        }
+        // or
+        df.groupBy(city).aggregate {
+            count() into "total"
+            count { age > 18 } into "adults"
+            median(age) into "median age"
+            min(age) into "min age"
+            maxBy(age)[name] into "name of oldest"
+        }
+        // or
+        df.groupBy(city).aggregate {
+            count() into "total"
+            age().count { it > 18 } into "adults"
+            age().median() into "median age"
+            age().min() into "min age"
+            maxBy(age)[name] into "name of oldest"
+        }
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun groupByAggregations_strings() {
+        // SampleStart
+        df.groupBy("city").aggregate {
+            count() into "total"
+            count { "age"<Int>() > 18 } into "adults"
+            median("age") into "median age"
+            min("age") into "min age"
+            maxBy("age")["name"] into "oldest"
+        }
+        // or
+        df.groupBy("city").aggregate {
+            count() into "total"
+            count { "age"<Int>() > 18 } into "adults"
+            "age"<Int>().median() into "median age"
+            "age"<Int>().min() into "min age"
+            maxBy("age")["name"] into "oldest"
+        }
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun groupByAggregateWithoutInto_properties() {
+        // SampleStart
+        df.groupBy { city }.aggregate { maxBy { age }.name }
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun groupByAggregateWithoutInto_accessors() {
+        // SampleStart
+        val city by column<String?>()
+        val age by column<Int>()
+        val name by columnGroup()
+
+        df.groupBy { city }.aggregate { maxBy { age() }[name] }
+        // or
+        df.groupBy(city).aggregate { maxBy(age)[name] }
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun groupByAggregateWithoutInto_strings() {
+        // SampleStart
+        df.groupBy("city").aggregate { maxBy("age")["name"] }
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun groupByDirectAggregations_properties() {
+        // SampleStart
+        df.groupBy { city }.max() // max for every comparable column
+        df.groupBy { city }.mean() // mean for every numeric column
+        df.groupBy { city }.max { age } // max age into column "age"
+        df.groupBy { city }.sum("total weight") { weight } // sum of weights into column "total weight"
+        df.groupBy { city }.count() // number of rows into column "count"
+        df.groupBy { city }
+            .max { name.firstName.length() and name.lastName.length() } // maximum length of firstName or lastName into column "max"
+        df.groupBy { city }
+            .medianFor { age and weight } // median age into column "age", median weight into column "weight"
+        df.groupBy { city }
+            .minFor { (age into "min age") and (weight into "min weight") } // min age into column "min age", min weight into column "min weight"
+        df.groupBy { city }.meanOf("mean ratio") { weight?.div(age) } // mean of weight/age into column "mean ratio"
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun groupByDirectAggregations_accessors() {
+        // SampleStart
+        val city by column<String?>()
+        val age by column<Int>()
+        val weight by column<Int?>()
+        val name by columnGroup()
+        val firstName by name.column<String>()
+        val lastName by name.column<String>()
+
+        df.groupBy { city }.max() // max for every comparable column
+        df.groupBy { city }.mean() // mean for every numeric column
+        df.groupBy { city }.max { age } // max age into column "age"
+        df.groupBy { city }.sum("total weight") { weight } // sum of weights into column "total weight"
+        df.groupBy { city }.count() // number of rows into column "count"
+        df.groupBy { city }
+            .max { firstName.length() and lastName.length() } // maximum length of firstName or lastName into column "max"
+        df.groupBy { city }
+            .medianFor { age and weight } // median age into column "age", median weight into column "weight"
+        df.groupBy { city }
+            .minFor { (age into "min age") and (weight into "min weight") } // min age into column "min age", min weight into column "min weight"
+        df.groupBy { city }.meanOf("mean ratio") { weight()?.div(age()) } // mean of weight/age into column "mean ratio"
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun groupByDirectAggregations_strings() {
+        // SampleStart
+        df.groupBy("city").max() // max for every comparable column
+        df.groupBy("city").mean() // mean for every numeric column
+        df.groupBy("city").max("age") // max age into column "age"
+        df.groupBy("city").sum("weight", name = "total weight") // sum of weights into column "total weight"
+        df.groupBy("city").count() // number of rows into column "count"
+        df.groupBy("city").max {
+            "name"["firstName"]<String>().length() and "name"["lastName"]<String>().length()
+        } // maximum length of firstName or lastName into column "max"
+        df.groupBy("city")
+            .medianFor("age", "weight") // median age into column "age", median weight into column "weight"
+        df.groupBy("city")
+            .minFor { ("age"<Int>() into "min age") and ("weight"<Int?>() into "min weight") } // min age into column "min age", min weight into column "min weight"
+        df.groupBy("city").meanOf("mean ratio") {
+            "weight"<Int?>()?.div("age"<Int>())
+        } // mean of weight/age into column "mean ratio"
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun groupByWithoutAggregation_properties() {
+        // SampleStart
+        df.groupBy { city }.values()
+        df.groupBy { city }.values { name and age }
+        df.groupBy { city }.values { weight into "weights" }
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun groupByWithoutAggregation_accessors() {
+        // SampleStart
+        val city by column<String?>()
+        val age by column<Int>()
+        val weight by column<Int?>()
+        val name by columnGroup()
+
+        df.groupBy(city).values()
+        df.groupBy(city).values(name, age)
+        df.groupBy(city).values { weight into "weights" }
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun groupByWithoutAggregation_strings() {
+        // SampleStart
+        df.groupBy("city").values()
+        df.groupBy("city").values("name", "age")
+        df.groupBy("city").values { "weight" into "weights" }
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun pivot_properties() {
+        // SampleStart
+        df.pivot { city }
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun pivot_accessors() {
+        // SampleStart
+        val city by column<String?>()
+
+        df.pivot { city }
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun pivot_strings() {
+        // SampleStart
+        df.pivot("city")
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun pivot2_properties() {
+        // SampleStart
+        df.pivot { city and name.firstName }
+        df.pivot { city then name.firstName }
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun pivot2_accessors() {
+        // SampleStart
+        val city by column<String?>()
+        val name by columnGroup()
+        val firstName by name.column<String>()
+
+        df.pivot { city and firstName }
+        df.pivot { city then firstName }
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun pivot2_strings() {
+        // SampleStart
+        df.pivot { "city" and "name"["firstName"] }
+        df.pivot { "city" then "name"["firstName"] }
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun pivotInward_properties() {
+        // SampleStart
+        df.pivot(inward = true) { city }
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun pivotInward_accessors() {
+        // SampleStart
+        val city by column<String?>()
+
+        df.pivot(inward = true) { city }
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun pivotInward_strings() {
+        // SampleStart
+        df.pivot("city", inward = true)
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun pivotAsDataRowOrFrame() {
+        // SampleStart
+        df.pivot { city }.frames()
+        df.pivot { city }.groupBy { name }.frames()
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun pivotGroupBy_properties() {
+        // SampleStart
+        df.pivot { city }.groupBy { name }
+        // same as
+        df.groupBy { name }.pivot { city }
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun pivotGroupBy_accessors() {
+        // SampleStart
+        val city by column<String?>()
+        val name by columnGroup()
+
+        df.pivot { city }.groupBy { name }
+        // same as
+        df.groupBy { name }.pivot { city }
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun pivotGroupBy_strings() {
+        // SampleStart
+        df.pivot("city").groupBy("name")
+        // same as
+        df.groupBy("name").pivot("city")
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun pivotGroupByOther() {
+        // SampleStart
+        df.pivot { city }.groupByOther()
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun pivotAggregate_properties() {
+        // SampleStart
+        df.pivot { city }.aggregate { minBy { age }.name }
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun pivotAggregate1_properties() {
+        // SampleStart
+        df.pivot { city }.groupBy { name.firstName }.aggregate {
+            meanFor { age and weight } into "means"
+            stdFor { age and weight } into "stds"
+            maxByOrNull { weight }?.name?.lastName into "biggest"
+        }
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun pivotAggregate_accessors() {
+        // SampleStart
+        val city by column<String?>()
+        val name by columnGroup()
+        val firstName by name.column<String>()
+        val age by column<Int>()
+        val weight by column<Int?>()
+
+        df.pivot { city }.aggregate { minBy(age).name }
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun pivotAggregate1_accessors() {
+        // SampleStart
+        val city by column<String?>()
+        val name by columnGroup()
+        val firstName by name.column<String>()
+        val age by column<Int>()
+        val weight by column<Int?>()
+
+        df.pivot { city }.groupBy { firstName }.aggregate {
+            meanFor { age and weight } into "means"
+            stdFor { age and weight } into "stds"
+            maxByOrNull(weight)?.name?.lastName into "biggest"
+        }
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun pivotAggregate_strings() {
+        // SampleStart
+        df.pivot("city").aggregate { minBy("age")["name"] }
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun pivotAggregate1_strings() {
+        // SampleStart
+        df.pivot("city").groupBy { "name"["firstName"] }.aggregate {
+            meanFor("age", "weight") into "means"
+            stdFor("age", "weight") into "stds"
+            maxByOrNull("weight")?.getColumnGroup("name")?.get("lastName") into "biggest"
+        }
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun pivotCommonAggregations_properties() {
+        // SampleStart
+        df.pivot { city }.maxFor { age and weight }
+        df.groupBy { name }.pivot { city }.median { age }
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun pivotCommonAggregations_accessors() {
+        // SampleStart
+        val city by column<String?>()
+        val name by columnGroup()
+        val age by column<Int>()
+        val weight by column<Int?>()
+
+        df.pivot { city }.maxFor { age and weight }
+        df.groupBy { name }.pivot { city }.median { age }
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun pivotCommonAggregations_strings() {
+        // SampleStart
+        df.pivot("city").maxFor("age", "weight")
+        df.groupBy("name").pivot("city").median("age")
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun pivotSeparate_properties() {
+        // SampleStart
+        df.pivot { city }.maxFor(separate = true) { age and weight }
+        df.pivot { city }.aggregate(separate = true) {
+            min { age } into "min age"
+            maxOrNull { weight } into "max weight"
+        }
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun pivotSeparate_accessors() {
+        // SampleStart
+        val city by column<String?>()
+        val age by column<Int>()
+        val weight by column<Int?>()
+
+        df.pivot { city }.maxFor(separate = true) { age and weight }
+        df.pivot { city }.aggregate(separate = true) {
+            min { age } into "min age"
+            maxOrNull { weight } into "max weight"
+        }
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun pivotSeparate_strings() {
+        // SampleStart
+        df.pivot("city").maxFor("age", "weight", separate = true)
+        df.pivot("city").aggregate(separate = true) {
+            min("age") into "min age"
+            maxOrNull("weight") into "max weight"
+        }
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun pivotDefault_properties() {
+        // SampleStart
+        df.pivot { city }.groupBy { name }.aggregate { min { age } default 0 }
+        df.pivot { city }.groupBy { name }.default(0).min()
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun pivotDefault1_properties() {
+        // SampleStart
+        df.pivot { city }.groupBy { name }.aggregate {
+            median { age } into "median age" default 0
+            minOrNull { weight } into "min weight" default 100
+        }
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun pivotDefault_accessors() {
+        // SampleStart
+        val city by column<String?>()
+        val age by column<Int>()
+        val weight by column<Int?>()
+        val name by columnGroup()
+
+        df.pivot { city }.groupBy { name }.aggregate { min { age } default 0 }
+        df.pivot { city }.groupBy { name }.default(0).min()
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun pivotDefault1_accessors() {
+        // SampleStart
+        val city by column<String?>()
+        val age by column<Int>()
+        val weight by column<Int?>()
+        val name by columnGroup()
+
+        df.pivot { city }.groupBy { name }.aggregate {
+            median { age } into "median age" default 0
+            minOrNull { weight } into "min weight" default 100
+        }
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun pivotDefault_strings() {
+        // SampleStart
+        df.pivot("city").groupBy("name").aggregate { min("age") default 0 }
+        df.pivot("city").groupBy("name").default(0).min()
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun pivotDefault1_strings() {
+        // SampleStart
+        df.pivot("city").groupBy("name").aggregate {
+            median("age") into "median age" default 0
+            minOrNull("weight") into "min weight" default 100
+        }
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun pivotInAggregate_properties() {
+        // SampleStart
+        df.groupBy { name.firstName }.aggregate {
+            pivot { city }.aggregate(separate = true) {
+                mean { age } into "mean age"
+                count() into "count"
+            }
+            count() into "total"
+        }
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun pivotInAggregate_accessors() {
+        // SampleStart
+        val city by column<String?>()
+        val name by columnGroup()
+        val firstName by name.column<String>()
+        val age by column<Int>()
+
+        df.groupBy { firstName }.aggregate {
+            pivot { city }.aggregate(separate = true) {
+                mean { age } into "mean age"
+                count() into "count"
+            }
+            count() into "total"
+        }
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun pivotInAggregate_strings() {
+        // SampleStart
+        df.groupBy { "name"["firstName"] }.aggregate {
+            pivot("city").aggregate(separate = true) {
+                mean("age") into "mean age"
+                count() into "count"
+            }
+            count() into "total"
+        }
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun pivotCounts() {
+        // SampleStart
+        df.pivotCounts { city }
+        // same as
+        df.pivot { city }.groupByOther().count()
+
+        df.groupBy { name }.pivotCounts { city }
+        // same as
+        df.groupBy { name }.pivot { city }.count()
+        // same as
+        df.groupBy { name }.aggregate {
+            pivotCounts { city }
+        }
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun pivotMatches() {
+        // SampleStart
+        df.pivotMatches { city }
+        // same as
+        df.pivot { city }.groupByOther().matches()
+
+        df.groupBy { name }.pivotMatches { city }
+        // same as
+        df.groupBy { name }.pivot { city }.matches()
+        // same as
+        df.groupBy { name }.aggregate {
+            pivotMatches { city }
+        }
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun cumSum() {
+        // SampleStart
+        df.cumSum { weight }
+        df.weight.cumSum()
+        df.groupBy { city }.cumSum { weight }.concat()
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun valueCounts() {
+        // SampleStart
+        df.city.valueCounts()
+
+        df.valueCounts { name and city }
+        // SampleEnd
+    }
+}
diff --git a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/samples/api/ApiLevels.kt b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/samples/api/ApiLevels.kt
new file mode 100644
index 000000000..429638923
--- /dev/null
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/samples/api/ApiLevels.kt
@@ -0,0 +1,148 @@
+@file:Suppress("ktlint")
+
+package org.jetbrains.kotlinx.dataframe.samples.api
+
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.annotations.ColumnName
+import org.jetbrains.kotlinx.dataframe.annotations.DataSchema
+import org.jetbrains.kotlinx.dataframe.api.add
+import org.jetbrains.kotlinx.dataframe.api.cast
+import org.jetbrains.kotlinx.dataframe.api.column
+import org.jetbrains.kotlinx.dataframe.api.dropNulls
+import org.jetbrains.kotlinx.dataframe.api.filter
+import org.jetbrains.kotlinx.dataframe.api.toListOf
+import org.jetbrains.kotlinx.dataframe.explainer.TransformDataFrameExpressions
+import org.jetbrains.kotlinx.dataframe.io.read
+import org.junit.Ignore
+import org.junit.Test
+
+@Ignore
+class ApiLevels {
+
+    @Test
+    @TransformDataFrameExpressions
+    fun strings() {
+        // SampleStart
+        DataFrame.read("titanic.csv")
+            .add("lastName") { "name"<String>().split(",").last() }
+            .dropNulls("age")
+            .filter {
+                "survived"<Boolean>() &&
+                    "home"<String>().endsWith("NY") &&
+                    "age"<Int>() in 10..20
+            }
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun accessors1() {
+        // SampleStart
+        val survived by column<Boolean>() // accessor for Boolean column with name 'survived'
+        val home by column<String>()
+        val age by column<Int?>()
+        val name by column<String>()
+        val lastName by column<String>()
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun accessors2() {
+        val survived by column<Boolean>()
+        val home by column<String>()
+        val age by column<Int?>()
+        val name by column<String>()
+        val lastName by column<String>()
+        // SampleStart
+
+        DataFrame.read("titanic.csv")
+            .add(lastName) { name().split(",").last() }
+            .dropNulls { age }
+            .filter { survived() && home().endsWith("NY") && age()!! in 10..20 }
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun accessors3() {
+        // SampleStart
+        val survived by column<Boolean>()
+        val home by column<String>()
+        val age by column<Int?>()
+        val name by column<String>()
+        val lastName by column<String>()
+
+        DataFrame.read("titanic.csv")
+            .add(lastName) { name().split(",").last() }
+            .dropNulls { age }
+            .filter { survived() && home().endsWith("NY") && age()!! in 10..20 }
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun kproperties1() {
+        // SampleStart
+        data class Passenger(
+            val survived: Boolean,
+            val home: String,
+            val age: Int,
+            val lastName: String
+        )
+
+        val passengers = DataFrame.read("titanic.csv")
+            .add(Passenger::lastName) { "name"<String>().split(",").last() }
+            .dropNulls(Passenger::age)
+            .filter {
+                it[Passenger::survived] &&
+                    it[Passenger::home].endsWith("NY") &&
+                    it[Passenger::age] in 10..20
+            }
+            .toListOf<Passenger>()
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun kproperties2() {
+        // SampleStart
+        data class Passenger(
+            @ColumnName("survived") val isAlive: Boolean,
+            @ColumnName("home") val city: String,
+            val name: String
+        )
+
+        val passengers = DataFrame.read("titanic.csv")
+            .filter { it[Passenger::city].endsWith("NY") }
+            .toListOf<Passenger>()
+        // SampleEnd
+    }
+
+    @DataSchema
+    interface TitanicPassenger {
+        val survived: Boolean
+        val home: String
+        val age: Int
+        val name: String
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun extensionProperties2() {
+        val df = DataFrame.read("titanic.csv").cast<TitanicPassenger>()
+        // SampleStart
+        df.add("lastName") { name.split(",").last() }
+            .dropNulls { age }
+            .filter { survived && home.endsWith("NY") && age in 10..20 }
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun extensionProperties1() {
+        // SampleStart
+        val df /* : AnyFrame */ = DataFrame.read("titanic.csv")
+        // SampleEnd
+    }
+}
diff --git a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/samples/api/Collections.kt b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/samples/api/Collections.kt
new file mode 100644
index 000000000..5456a9614
--- /dev/null
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/samples/api/Collections.kt
@@ -0,0 +1,91 @@
+@file:Suppress("ktlint")
+
+package org.jetbrains.kotlinx.dataframe.samples.api
+
+import io.kotest.matchers.shouldBe
+import org.jetbrains.kotlinx.dataframe.annotations.DataSchema
+import org.jetbrains.kotlinx.dataframe.api.add
+import org.jetbrains.kotlinx.dataframe.api.dataFrameOf
+import org.jetbrains.kotlinx.dataframe.api.group
+import org.jetbrains.kotlinx.dataframe.api.into
+import org.jetbrains.kotlinx.dataframe.api.toDataFrame
+import org.jetbrains.kotlinx.dataframe.api.toListOf
+import org.jetbrains.kotlinx.dataframe.explainer.TransformDataFrameExpressions
+import org.junit.Test
+
+class Collections {
+
+    @Test
+    @TransformDataFrameExpressions
+    fun listInterop1() {
+        // SampleStart
+        data class Input(val a: Int, val b: Int)
+
+        val list = listOf(Input(1, 2), Input(3, 4))
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun listInterop2() {
+        data class Input(val a: Int, val b: Int)
+
+        val list = listOf(Input(1, 2), Input(3, 4))
+        // SampleStart
+        val df = list.toDataFrame()
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun listInterop3() {
+        val list = listOf(Input(1, 2), Input(3, 4))
+        val df = list.toDataFrame()
+
+        // SampleStart
+        @DataSchema
+        data class Input(val a: Int, val b: Int)
+
+        val df2 = df.add("c") { a + b }
+        // SampleEnd
+    }
+
+    @DataSchema
+    data class Input(val a: Int, val b: Int)
+
+    @DataSchema
+    interface Input2 {
+        val a: Int
+        val b: Int
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun listInterop4() {
+        val list = listOf(Input(1, 2), Input(3, 4))
+        val df2 = list.toDataFrame().add("c") { a + b }
+
+        // SampleStart
+        data class Output(val a: Int, val b: Int, val c: Int)
+
+        val result = df2.toListOf<Output>()
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun listInterop5() {
+        // SampleStart
+        val df = dataFrameOf("name", "lastName", "age")("John", "Doe", 21)
+            .group("name", "lastName").into("fullName")
+
+        data class FullName(val name: String, val lastName: String)
+
+        data class Person(val fullName: FullName, val age: Int)
+
+        val persons = df.toListOf<Person>() // [Person(fullName = FullName(name = "John", lastName = "Doe"), age = 21)]
+        // SampleEnd
+
+        persons shouldBe listOf(Person(FullName("John", "Doe"), 21))
+    }
+}
diff --git a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/samples/api/Create.kt b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/samples/api/Create.kt
new file mode 100644
index 000000000..b98992df6
--- /dev/null
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/samples/api/Create.kt
@@ -0,0 +1,469 @@
+@file:Suppress("ktlint")
+
+package org.jetbrains.kotlinx.dataframe.samples.api
+
+import io.kotest.matchers.shouldBe
+import org.jetbrains.kotlinx.dataframe.AnyFrame
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.api.DynamicDataFrameBuilder
+import org.jetbrains.kotlinx.dataframe.api.Infer
+import org.jetbrains.kotlinx.dataframe.api.ValueProperty
+import org.jetbrains.kotlinx.dataframe.api.add
+import org.jetbrains.kotlinx.dataframe.api.column
+import org.jetbrains.kotlinx.dataframe.api.columnGroup
+import org.jetbrains.kotlinx.dataframe.api.columnOf
+import org.jetbrains.kotlinx.dataframe.api.dataFrameOf
+import org.jetbrains.kotlinx.dataframe.api.emptyDataFrame
+import org.jetbrains.kotlinx.dataframe.api.filter
+import org.jetbrains.kotlinx.dataframe.api.frameColumn
+import org.jetbrains.kotlinx.dataframe.api.map
+import org.jetbrains.kotlinx.dataframe.api.named
+import org.jetbrains.kotlinx.dataframe.api.preserve
+import org.jetbrains.kotlinx.dataframe.api.print
+import org.jetbrains.kotlinx.dataframe.api.sortBy
+import org.jetbrains.kotlinx.dataframe.api.toColumn
+import org.jetbrains.kotlinx.dataframe.api.toColumnOf
+import org.jetbrains.kotlinx.dataframe.api.toDataFrame
+import org.jetbrains.kotlinx.dataframe.api.value
+import org.jetbrains.kotlinx.dataframe.api.withValues
+import org.jetbrains.kotlinx.dataframe.columns.ColumnKind
+import org.jetbrains.kotlinx.dataframe.explainer.TransformDataFrameExpressions
+import org.jetbrains.kotlinx.dataframe.kind
+import org.jetbrains.kotlinx.dataframe.type
+import org.junit.Test
+import java.io.File
+import kotlin.reflect.typeOf
+
+class Create : TestBase() {
+
+    @Test
+    @TransformDataFrameExpressions
+    fun createValueByColumnOf() {
+        // SampleStart
+        // Create ValueColumn with name 'student' and two elements of type String
+        val student by columnOf("Alice", "Bob")
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun createValueByToColumn() {
+        // SampleStart
+        listOf("Alice", "Bob").toColumn("name")
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun columnAccessorsUsage() {
+        // SampleStart
+        val age by column<Int>()
+
+        // Access fourth cell in the "age" column of dataframe `df`.
+        // This expression returns `Int` because variable `age` has `ColumnAccessor<Int>` type.
+        // If dataframe `df` has no column "age" or column "age" has type which is incompatible with `Int`,
+        // runtime exception will be thrown.
+        df[age][3] + 5
+
+        // Access first cell in the "age" column of dataframe `df`.
+        df[0][age] * 2
+
+        // Returns new dataframe sorted by age column (ascending)
+        df.sortBy(age)
+
+        // Returns new dataframe with the column "year of birth" added
+        df.add("year of birth") { 2021 - age }
+
+        // Returns new dataframe containing only rows with age > 30
+        df.filter { age > 30 }
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun columnAccessorToColumn() {
+        // SampleStart
+        val age by column<Int>()
+        val ageCol1 = age.withValues(15, 20)
+        val ageCol2 = age.withValues(1..10)
+        // SampleEnd
+
+        ageCol2.size() shouldBe 10
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun columnAccessorMap() {
+        // SampleStart
+        val age by column<Int>()
+        val year by age.map { 2021 - it }
+
+        df.filter { year > 2000 }
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun columnAccessorComputed_properties() {
+        // SampleStart
+        val fullName by column(df) { name.firstName + " " + name.lastName }
+
+        df[fullName]
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun columnAccessorComputed_accessors() {
+        // SampleStart
+        val name by columnGroup()
+        val firstName by name.column<String>()
+        val lastName by name.column<String>()
+
+        val fullName by column { firstName() + " " + lastName() }
+
+        df[fullName]
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun columnAccessorComputed_strings() {
+        // SampleStart
+
+        val fullName by column { "name"["firstName"]<String>() + " " + "name"["lastName"]<String>() }
+
+        df[fullName]
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun createValueColumnInferred() {
+        // SampleStart
+        val values: List<Any?> = listOf(1, 2.5)
+
+        values.toColumn("data") // type: Any?
+        values.toColumn("data", Infer.Type) // type: Number
+        values.toColumn("data", Infer.Nulls) // type: Any
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun createValueColumnOfType() {
+        // SampleStart
+        val values: List<Any?> = listOf(1, 2.5)
+
+        values.toColumnOf<Number?>("data") // type: Number?
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun createColumnRenamed() {
+        // SampleStart
+        val column = columnOf("Alice", "Bob") named "student"
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun createColumnGroup() {
+        // SampleStart
+        val firstName by columnOf("Alice", "Bob")
+        val lastName by columnOf("Cooper", "Marley")
+
+        // Create ColumnGroup with two nested columns
+        val fullName by columnOf(firstName, lastName)
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun createFrameColumn() {
+        // SampleStart
+        val df1 = dataFrameOf("name", "age")("Alice", 20, "Bob", 25)
+        val df2 = dataFrameOf("name", "temp")("Charlie", 36.6)
+
+        // Create FrameColumn with two elements of type DataFrame
+        val frames by columnOf(df1, df2)
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun createColumnAccessor() {
+        // SampleStart
+        val name by column<String>()
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun createColumnAccessorRenamed() {
+        // SampleStart
+        val accessor by column<String>("complex column name")
+        // SampleEnd
+        accessor.name() shouldBe "complex column name"
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun createDeepColumnAccessor() {
+        // SampleStart
+        val name by columnGroup()
+        val firstName by name.column<String>()
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun createGroupOrFrameColumnAccessor() {
+        // SampleStart
+        val columns by columnGroup()
+        val frames by frameColumn()
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun createEmptyDataFrame() {
+        // SampleStart
+        val df = emptyDataFrame<Any>()
+        // SampleEnd
+        df.columnsCount() shouldBe 0
+        df.rowsCount() shouldBe 0
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun createDataFrameOf() {
+        // SampleStart
+        // DataFrame with 2 columns and 3 rows
+        val df = dataFrameOf("name", "age")(
+            "Alice", 15,
+            "Bob", 20,
+            "Charlie", 100,
+        )
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun createDataFrameOfPairs() {
+        // SampleStart
+        // DataFrame with 2 columns and 3 rows
+        val df = dataFrameOf(
+            "name" to listOf("Alice", "Bob", "Charlie"),
+            "age" to listOf(15, 20, 100),
+        )
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun createDataFrameWithFill() {
+        // SampleStart
+        // Multiplication table
+        dataFrameOf(1..10) { x -> (1..10).map { x * it } }
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun createDataFrameFillConstant() {
+        // SampleStart
+        val names = listOf("first", "second", "third")
+
+        // DataFrame with 3 columns, fill each column with 15 `true` values
+        val df = dataFrameOf(names).fill(15, true)
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun createDataFrameWithRandom() {
+        // SampleStart
+        // 5 columns filled with 7 random double values:
+        val names = (1..5).map { "column$it" }
+        dataFrameOf(names).randomDouble(7)
+
+        // 5 columns filled with 7 random double values between 0 and 1 (inclusive)
+        dataFrameOf(names).randomDouble(7, 0.0..1.0).print()
+
+        // 5 columns filled with 7 random int values between 0 and 100 (inclusive)
+        dataFrameOf(names).randomInt(7, 0..100).print()
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun createDataFrameFromColumns() {
+        // SampleStart
+
+        val name by columnOf("Alice", "Bob", "Charlie")
+        val age by columnOf(15, 20, 22)
+
+        // DataFrame with 2 columns
+        val df = dataFrameOf(name, age)
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun createDataFrameFromMap() {
+        // SampleStart
+        val map = mapOf("name" to listOf("Alice", "Bob", "Charlie"), "age" to listOf(15, 20, 22))
+
+        // DataFrame with 2 columns
+        map.toDataFrame()
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun createDataFrameFromIterable() {
+        // SampleStart
+        val name by columnOf("Alice", "Bob", "Charlie")
+        val age by columnOf(15, 20, 22)
+
+        listOf(name, age).toDataFrame()
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun createDataFrameFromNamesAndValues() {
+        // SampleStart
+        val names = listOf("name", "age")
+        val values = listOf(
+            "Alice", 15,
+            "Bob", 20,
+            "Charlie", 22,
+        )
+        val df = dataFrameOf(names, values)
+        // SampleEnd
+        df.columnNames() shouldBe listOf("name", "age")
+        df.rowsCount() shouldBe 3
+        df["name"].type() shouldBe typeOf<String>()
+        df["age"].type() shouldBe typeOf<Int>()
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun readDataFrameFromValues() {
+        // SampleStart
+        val names = listOf("Alice", "Bob", "Charlie")
+        val df: DataFrame<ValueProperty<String>> = names.toDataFrame()
+        df.add("length") { value.length }
+        // SampleEnd
+        df.value.toList() shouldBe names
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun readDataFrameFromObject() {
+        // SampleStart
+        data class Person(val name: String, val age: Int)
+
+        val persons = listOf(Person("Alice", 15), Person("Bob", 20), Person("Charlie", 22))
+
+        val df = persons.toDataFrame()
+        // SampleEnd
+        df.columnsCount() shouldBe 2
+        df.rowsCount() shouldBe 3
+        df["name"].type() shouldBe typeOf<String>()
+        df["age"].type() shouldBe typeOf<Int>()
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun readDataFrameFromDeepObject() {
+        // SampleStart
+        data class Name(val firstName: String, val lastName: String)
+
+        data class Score(val subject: String, val value: Int)
+
+        data class Student(val name: Name, val age: Int, val scores: List<Score>)
+
+        val students = listOf(
+            Student(Name("Alice", "Cooper"), 15, listOf(Score("math", 4), Score("biology", 3))),
+            Student(Name("Bob", "Marley"), 20, listOf(Score("music", 5))),
+        )
+
+        val df = students.toDataFrame(maxDepth = 1)
+        // SampleEnd
+        df.columnsCount() shouldBe 3
+        df.rowsCount() shouldBe 2
+        df["name"].kind shouldBe ColumnKind.Group
+        df["name"]["firstName"].type() shouldBe typeOf<String>()
+        df["scores"].kind shouldBe ColumnKind.Frame
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun readDataFrameFromDeepObjectWithExclude() {
+        data class Name(val firstName: String, val lastName: String)
+
+        data class Score(val subject: String, val value: Int)
+
+        data class Student(val name: Name, val age: Int, val scores: List<Score>)
+
+        val students = listOf(
+            Student(Name("Alice", "Cooper"), 15, listOf(Score("math", 4), Score("biology", 3))),
+            Student(Name("Bob", "Marley"), 20, listOf(Score("music", 5))),
+        )
+
+        // SampleStart
+        val df = students.toDataFrame {
+            // add column
+            "year of birth" from { 2021 - it.age }
+
+            // scan all properties
+            properties(maxDepth = 1) {
+                exclude(Score::subject) // `subject` property will be skipped from object graph traversal
+                preserve<Name>() // `Name` objects will be stored as-is without transformation into DataFrame
+            }
+
+            // add column group
+            "summary" {
+                "max score" from { it.scores.maxOf { it.value } }
+                "min score" from { it.scores.minOf { it.value } }
+            }
+        }
+        // SampleEnd
+        df.columnsCount() shouldBe 5
+        df.rowsCount() shouldBe 2
+        df["name"].kind shouldBe ColumnKind.Value
+        df["name"].type shouldBe typeOf<Name>()
+        df["scores"].kind shouldBe ColumnKind.Frame
+        df["summary"]["min score"].values() shouldBe listOf(3, 5)
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun duplicatedColumns() {
+        // SampleStart
+        fun peek(vararg dataframes: AnyFrame): AnyFrame {
+            val builder = DynamicDataFrameBuilder()
+            for (df in dataframes) {
+                df.columns().firstOrNull()?.let { builder.add(it) }
+            }
+            return builder.toDataFrame()
+        }
+
+        val col by columnOf(1, 2, 3)
+        peek(dataFrameOf(col), dataFrameOf(col))
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun toDataFrameColumn() {
+        // SampleStart
+        val files = listOf(File("data.csv"), File("data1.csv"))
+        val df = files.toDataFrame(columnName = "data")
+        // SampleEnd
+    }
+}
diff --git a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/samples/api/DataRowApi.kt b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/samples/api/DataRowApi.kt
new file mode 100644
index 000000000..715051247
--- /dev/null
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/samples/api/DataRowApi.kt
@@ -0,0 +1,49 @@
+@file:Suppress("ktlint")
+
+package org.jetbrains.kotlinx.dataframe.samples.api
+
+import org.jetbrains.kotlinx.dataframe.api.add
+import org.jetbrains.kotlinx.dataframe.api.at
+import org.jetbrains.kotlinx.dataframe.api.diffOrNull
+import org.jetbrains.kotlinx.dataframe.api.drop
+import org.jetbrains.kotlinx.dataframe.api.filter
+import org.jetbrains.kotlinx.dataframe.api.pivot
+import org.jetbrains.kotlinx.dataframe.api.prev
+import org.jetbrains.kotlinx.dataframe.api.update
+import org.jetbrains.kotlinx.dataframe.api.where
+import org.jetbrains.kotlinx.dataframe.api.with
+import org.jetbrains.kotlinx.dataframe.explainer.TransformDataFrameExpressions
+import org.junit.Test
+
+class DataRowApi : TestBase() {
+
+    @Test
+    @TransformDataFrameExpressions
+    fun expressions() {
+        // SampleStart
+        // Row expression computes values for a new column
+        df.add("fullName") { name.firstName + " " + name.lastName }
+
+        // Row expression computes updated values
+        df.update { weight }.at(1, 3, 4).with { prev()?.weight }
+
+        // Row expression computes cell content for values of pivoted column
+        df.pivot { city }.with { name.lastName.uppercase() }
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun conditions() {
+        // SampleStart
+        // Row condition is used to filter rows by index
+        df.filter { index() % 5 == 0 }
+
+        // Row condition is used to drop rows where `age` is the same as in the previous row
+        df.drop { diffOrNull { age } == 0 }
+
+        // Row condition is used to filter rows for value update
+        df.update { weight }.where { index() > 4 && city != "Paris" }.with { 50 }
+        // SampleEnd
+    }
+}
diff --git a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/samples/api/Join.kt b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/samples/api/Join.kt
new file mode 100644
index 000000000..f4a245297
--- /dev/null
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/samples/api/Join.kt
@@ -0,0 +1,139 @@
+@file:Suppress("ktlint")
+
+package org.jetbrains.kotlinx.dataframe.samples.api
+
+import io.kotest.matchers.shouldBe
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.api.add
+import org.jetbrains.kotlinx.dataframe.api.cast
+import org.jetbrains.kotlinx.dataframe.api.column
+import org.jetbrains.kotlinx.dataframe.api.columnGroup
+import org.jetbrains.kotlinx.dataframe.api.excludeJoin
+import org.jetbrains.kotlinx.dataframe.api.fullJoin
+import org.jetbrains.kotlinx.dataframe.api.getColumnGroup
+import org.jetbrains.kotlinx.dataframe.api.innerJoin
+import org.jetbrains.kotlinx.dataframe.api.into
+import org.jetbrains.kotlinx.dataframe.api.join
+import org.jetbrains.kotlinx.dataframe.api.leftJoin
+import org.jetbrains.kotlinx.dataframe.api.rename
+import org.jetbrains.kotlinx.dataframe.api.rightJoin
+import org.jetbrains.kotlinx.dataframe.api.select
+import org.jetbrains.kotlinx.dataframe.columns.ColumnGroup
+import org.jetbrains.kotlinx.dataframe.explainer.TransformDataFrameExpressions
+import org.junit.Test
+
+class Join : TestBase() {
+
+    private val other = df.add("year") { 2021 - age }.select { name and city and "year" }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun join_properties() {
+        // SampleStart
+        df.join(other) { name and city }
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun join_accessors() {
+        // SampleStart
+        val name by columnGroup()
+        val city by column<String>()
+
+        df.join(other) { name and city }
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun join_strings() {
+        // SampleStart
+        df.join(other, "name", "city")
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun joinDefault() {
+        // SampleStart
+        df.join(other)
+        // SampleEnd
+    }
+
+    class Right
+
+    val DataFrame<Right>.fullName: ColumnGroup<Name> get() = getColumnGroup("fullName").cast()
+
+    @Test
+    @TransformDataFrameExpressions
+    fun joinWithMatch_properties() {
+        val other = other.rename { name }.into("fullName").cast<Right>()
+        val joined =
+            // SampleStart
+            df.join(other) { name match right.fullName }
+        // SampleEnd
+        joined.rowsCount() shouldBe df.rowsCount()
+        joined.columnsCount() shouldBe df.columnsCount() + 2
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun joinWithMatch_accessors() {
+        val other = df.add("year") { 2021 - age }.select { name named "fullName" and "year" }
+        // SampleStart
+        val name by columnGroup()
+        val fullName by columnGroup()
+
+        df.join(other) { name match fullName }
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun joinWithMatch_strings() {
+        val other = df.add("year") { 2021 - age }.select { name named "fullName" and "year" }
+        // SampleStart
+        df.join(other) { "name" match "fullName" }
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun joinSpecial_properties() {
+        // SampleStart
+        df.innerJoin(other) { name and city }
+        df.leftJoin(other) { name and city }
+        df.rightJoin(other) { name and city }
+        df.fullJoin(other) { name and city }
+        df.excludeJoin(other) { name and city }
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun joinSpecial_accessors() {
+        // SampleStart
+        val name by columnGroup()
+        val city by column<String>()
+
+        df.innerJoin(other) { name and city }
+        df.leftJoin(other) { name and city }
+        df.rightJoin(other) { name and city }
+        df.fullJoin(other) { name and city }
+        df.excludeJoin(other) { name and city }
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun joinSpecial_strings() {
+        // SampleStart
+        df.innerJoin(other, "name", "city")
+        df.leftJoin(other, "name", "city")
+        df.rightJoin(other, "name", "city")
+        df.fullJoin(other, "name", "city")
+        df.excludeJoin(other, "name", "city")
+        // SampleEnd
+    }
+}
diff --git a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/samples/api/JoinWith.kt b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/samples/api/JoinWith.kt
new file mode 100644
index 000000000..ed27336e9
--- /dev/null
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/samples/api/JoinWith.kt
@@ -0,0 +1,671 @@
+@file:Suppress("ktlint")
+
+package org.jetbrains.kotlinx.dataframe.samples.api
+
+import io.kotest.matchers.shouldBe
+import kotlinx.datetime.LocalDate
+import kotlinx.datetime.toJavaLocalDate
+import org.jetbrains.kotlinx.dataframe.AnyFrame
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.annotations.DataSchema
+import org.jetbrains.kotlinx.dataframe.api.FormattingDSL
+import org.jetbrains.kotlinx.dataframe.api.Infer
+import org.jetbrains.kotlinx.dataframe.api.JoinedDataRow
+import org.jetbrains.kotlinx.dataframe.api.RGBColor
+import org.jetbrains.kotlinx.dataframe.api.and
+import org.jetbrains.kotlinx.dataframe.api.cast
+import org.jetbrains.kotlinx.dataframe.api.colsOf
+import org.jetbrains.kotlinx.dataframe.api.column
+import org.jetbrains.kotlinx.dataframe.api.convert
+import org.jetbrains.kotlinx.dataframe.api.dataFrameOf
+import org.jetbrains.kotlinx.dataframe.api.excludeJoinWith
+import org.jetbrains.kotlinx.dataframe.api.filterJoinWith
+import org.jetbrains.kotlinx.dataframe.api.fullJoinWith
+import org.jetbrains.kotlinx.dataframe.api.getValue
+import org.jetbrains.kotlinx.dataframe.api.innerJoin
+import org.jetbrains.kotlinx.dataframe.api.innerJoinWith
+import org.jetbrains.kotlinx.dataframe.api.joinWith
+import org.jetbrains.kotlinx.dataframe.api.leftJoin
+import org.jetbrains.kotlinx.dataframe.api.leftJoinWith
+import org.jetbrains.kotlinx.dataframe.api.rightJoin
+import org.jetbrains.kotlinx.dataframe.api.rightJoinWith
+import org.jetbrains.kotlinx.dataframe.api.with
+import org.jetbrains.kotlinx.dataframe.explainer.PluginCallbackProxy
+import org.jetbrains.kotlinx.dataframe.explainer.SamplesDisplayConfiguration
+import org.jetbrains.kotlinx.dataframe.explainer.TransformDataFrameExpressions
+import org.jetbrains.kotlinx.dataframe.io.DataFrameHtmlData
+import org.jetbrains.kotlinx.dataframe.io.DisplayConfiguration
+import org.jetbrains.kotlinx.dataframe.io.renderValueForHtml
+import org.jetbrains.kotlinx.dataframe.io.toHTML
+import org.jetbrains.kotlinx.dataframe.jupyter.ChainedCellRenderer
+import org.jetbrains.kotlinx.dataframe.jupyter.DefaultCellRenderer
+import org.jetbrains.kotlinx.dataframe.jupyter.RenderedContent
+import org.junit.Test
+import java.time.format.DateTimeFormatter
+
+@Suppress("ktlint:standard:argument-list-wrapping")
+class JoinWith : TestBase() {
+
+    @DataSchema
+    interface Campaigns {
+        val name: String
+        val startDate: LocalDate
+        val endDate: LocalDate
+    }
+
+    @DataSchema
+    interface Visits {
+        val date: LocalDate
+        val userId: Int
+    }
+
+    private val campaigns = dataFrameOf("name", "startDate", "endDate")(
+        "Winter Sale", LocalDate(2023, 1, 1), LocalDate(2023, 1, 31),
+        "Spring Sale", LocalDate(2023, 4, 1), LocalDate(2023, 4, 30),
+        "Summer Sale", LocalDate(2023, 7, 1), LocalDate(2023, 7, 31),
+        "Autumn Sale", LocalDate(2023, 10, 1), LocalDate(2023, 10, 31),
+    ).cast<Campaigns>()
+
+    private val visits = dataFrameOf("date", "usedId")(
+        LocalDate(2023, 1, 10), 1,
+        LocalDate(2023, 1, 20), 2,
+        LocalDate(2023, 4, 15), 1,
+        LocalDate(2023, 5, 1), 3,
+        LocalDate(2023, 7, 10), 2,
+    ).cast<Visits>()
+
+    class ColoredValue<T>(val value: T, val backgroundColor: RGBColor, val textColor: RGBColor) {
+        override fun equals(other: Any?): Boolean {
+            if (this === other) return true
+            if (javaClass != other?.javaClass) return false
+
+            other as ColoredValue<*>
+
+            return value == other.value
+        }
+
+        override fun hashCode(): Int = value?.hashCode() ?: 0
+    }
+
+    private val renderer = object : ChainedCellRenderer(DefaultCellRenderer) {
+        override fun maybeContent(value: Any?, configuration: DisplayConfiguration): RenderedContent? =
+            if (value is ColoredValue<*>) {
+                if (value.value is LocalDate) {
+                    RenderedContent.text(
+                        DateTimeFormatter.ofPattern("dd MMMM yyyy").format(value.value.toJavaLocalDate()),
+                    )
+                } else {
+                    renderValueForHtml(value.value, configuration.cellContentLimit, configuration.decimalFormat)
+                }
+            } else {
+                null
+            }
+
+        override fun maybeTooltip(value: Any?, configuration: DisplayConfiguration): String? = null
+    }
+
+    private fun AnyFrame.unwrapColoredValues(): AnyFrame =
+        convert {
+            colsAtAnyDepth().colsOf<ColoredValue<*>?>()
+        }.with(Infer.Type) { it?.value }
+
+    private fun <T> T.colored(background: RGBColor, text: RGBColor) = ColoredValue(this, background, text)
+
+    private fun <T> T.winter(background: RGBColor = RGBColor(179, 205, 224), text: RGBColor = RGBColor(0, 0, 51)) =
+        ColoredValue(this, background, text)
+
+    private fun <T> T.spring(background: RGBColor = RGBColor(204, 235, 197), text: RGBColor = RGBColor(0, 51, 0)) =
+        ColoredValue(this, background, text)
+
+    private fun <T> T.summer(background: RGBColor = RGBColor(176, 224, 230), text: RGBColor = RGBColor(25, 25, 112)) =
+        ColoredValue(this, background, text)
+
+    private fun <T> T.autumn(background: RGBColor = RGBColor(221, 160, 221), text: RGBColor = RGBColor(85, 26, 139)) =
+        ColoredValue(this, background, text)
+
+    private val coloredCampaigns = dataFrameOf("name", "startDate", "endDate")(
+        "Winter Sale".winter(), LocalDate(2023, 1, 1).winter(), LocalDate(2023, 1, 31).winter(),
+        "Spring Sale".spring(), LocalDate(2023, 4, 1).spring(), LocalDate(2023, 4, 30).spring(),
+        "Summer Sale".summer(), LocalDate(2023, 7, 1).summer(), LocalDate(2023, 7, 31).summer(),
+        "Autumn Sale".autumn(), LocalDate(2023, 10, 1).autumn(), LocalDate(2023, 10, 31).autumn(),
+    )
+
+    @Suppress("ktlint:standard:chain-method-continuation", "ktlint:standard:max-line-length")
+    private val coloredVisits = dataFrameOf("date", "usedId")(
+        LocalDate(2023, 1, 10).winter(), 1.winter(),
+        LocalDate(2023, 1, 20).winter(), 2.winter(),
+        LocalDate(2023, 4, 15).spring(), 1.spring(),
+        LocalDate(2023, 5, 1).colored(FormattingDSL.white, FormattingDSL.black), 3.colored(FormattingDSL.white, FormattingDSL.black),
+        LocalDate(2023, 7, 10).summer(), 2.summer(),
+    )
+
+    private fun AnyFrame.toColoredHTML() =
+        toHTML(
+            getFooter = { null },
+            cellRenderer = renderer,
+            configuration = SamplesDisplayConfiguration.copy(
+                cellFormatter = { row, col ->
+                    val value = row[col]
+                    if (value is ColoredValue<*>) {
+                        background(value.backgroundColor) and textColor(value.textColor)
+                    } else {
+                        background(white)
+                    }
+                },
+            ),
+        )
+
+    private val joinExpression: JoinedDataRow<Any?, Any?>.(it: JoinedDataRow<Any?, Any?>) -> Boolean = {
+        right[{ "date"<ColoredValue<LocalDate>>() }].value in
+            "startDate"<ColoredValue<LocalDate>>().value.."endDate"<ColoredValue<LocalDate>>().value
+    }
+
+    private fun DataFrameHtmlData.wrap(title: String): DataFrameHtmlData =
+        copy(
+            body =
+            """
+                <div class="table-container">
+                    <b>$title</b>
+                    $body
+                </div>
+                """.trimIndent(),
+        )
+
+    private fun DataFrameHtmlData.wrap(): DataFrameHtmlData =
+        copy(
+            body =
+            """
+                <div class="table-container">
+                    $body
+                </div>
+                """.trimIndent(),
+        )
+
+    private fun snippetOutput(coloredResult: DataFrame<Any?>, result: DataFrame<Any?>) {
+        coloredCampaigns.unwrapColoredValues() shouldBe campaigns
+        coloredVisits.unwrapColoredValues() shouldBe visits
+        coloredResult.unwrapColoredValues() shouldBe result
+
+        PluginCallbackProxy.overrideHtmlOutput(
+            manualOutput = DataFrameHtmlData
+                .tableDefinitions()
+                .plus(coloredCampaigns.toColoredHTML().wrap("campaigns"))
+                .plus(coloredVisits.toColoredHTML().wrap("visits"))
+                .plus(coloredResult.toColoredHTML().wrap("result"))
+                .plus(
+                    DataFrameHtmlData(
+                        style =
+                        """
+                            body {
+                                display: flex;
+                                align-items: flex-start;
+                                overflow-x: auto;
+                                font-family: "JetBrains Mono", SFMono-Regular, Consolas, "Liberation Mono", Menlo, Courier, monospace;
+                                font-size: 14px;
+                            }
+
+                            :root {
+                                color: #19191C;
+                                background-color: #fff;
+                            }
+                            
+                            :root[theme="dark"] {
+                                background-color: #19191C;
+                                color: #FFFFFFCC
+                            }
+                            
+                            .table-container {
+                                margin-right: 20px; 
+                            }
+                            
+                            .table-container:not(:last-child) {
+                                margin-right: 20px; 
+                            }
+                            
+                            td {
+                                white-space: nowrap;
+                            }
+                            """.trimIndent(),
+                    ),
+                ),
+        )
+    }
+
+    @TransformDataFrameExpressions
+    @Test
+    fun joinWith_accessors() {
+        val result = run {
+            // SampleStart
+            val date by column<LocalDate>()
+            val startDate by column<LocalDate>()
+            val endDate by column<LocalDate>()
+
+            campaigns.innerJoinWith(visits) {
+                right[date] in startDate()..endDate()
+            }
+            // SampleEnd
+        }
+        val coloredResult = coloredCampaigns.innerJoinWith(coloredVisits, joinExpression = joinExpression)
+        snippetOutput(coloredResult, result)
+    }
+
+    @TransformDataFrameExpressions
+    @Test
+    fun filterJoinWith_accessors() {
+        val result = run {
+            // SampleStart
+            val date by column<LocalDate>()
+            val startDate by column<LocalDate>()
+            val endDate by column<LocalDate>()
+
+            campaigns.filterJoinWith(visits) {
+                right[date] in startDate()..endDate()
+            }
+            // SampleEnd
+        }
+        val coloredResult = coloredCampaigns.filterJoinWith(coloredVisits, joinExpression = joinExpression)
+        snippetOutput(coloredResult, result)
+    }
+
+    @TransformDataFrameExpressions
+    @Test
+    fun leftJoinWith_accessors() {
+        val result = run {
+            // SampleStart
+            val date by column<LocalDate>()
+            val startDate by column<LocalDate>()
+            val endDate by column<LocalDate>()
+
+            campaigns.leftJoinWith(visits) {
+                right[date] in startDate()..endDate()
+            }
+            // SampleEnd
+        }
+        val coloredResult = coloredCampaigns.leftJoinWith(coloredVisits, joinExpression = joinExpression)
+        snippetOutput(coloredResult, result)
+    }
+
+    @TransformDataFrameExpressions
+    @Test
+    fun rightJoinWith_accessors() {
+        val result = run {
+            // SampleStart
+            val date by column<LocalDate>()
+            val startDate by column<LocalDate>()
+            val endDate by column<LocalDate>()
+
+            campaigns.rightJoinWith(visits) {
+                right[date] in startDate()..endDate()
+            }
+            // SampleEnd
+        }
+        val coloredResult = coloredCampaigns.rightJoinWith(coloredVisits, joinExpression = joinExpression)
+        snippetOutput(coloredResult, result)
+    }
+
+    @TransformDataFrameExpressions
+    @Test
+    fun fullJoinWith_accessors() {
+        val result = run {
+            // SampleStart
+            val date by column<LocalDate>()
+            val startDate by column<LocalDate>()
+            val endDate by column<LocalDate>()
+
+            campaigns.fullJoinWith(visits) {
+                right[date] in startDate()..endDate()
+            }
+            // SampleEnd
+        }
+        val coloredResult = coloredCampaigns.fullJoinWith(coloredVisits, joinExpression = joinExpression)
+        snippetOutput(coloredResult, result)
+    }
+
+    @TransformDataFrameExpressions
+    @Test
+    fun excludeJoinWith_accessors() {
+        val result = run {
+            // SampleStart
+            val date by column<LocalDate>()
+            val startDate by column<LocalDate>()
+            val endDate by column<LocalDate>()
+
+            campaigns.excludeJoinWith(visits) {
+                right[date] in startDate()..endDate()
+            }
+            // SampleEnd
+        }
+        val coloredResult = coloredCampaigns.excludeJoinWith(coloredVisits, joinExpression = joinExpression)
+        snippetOutput(coloredResult, result)
+    }
+
+    @TransformDataFrameExpressions
+    @Test
+    fun joinWith_strings() {
+        val result =
+            // SampleStart
+            campaigns.innerJoinWith(visits) {
+                right.getValue<LocalDate>("date") in "startDate"<LocalDate>().."endDate"<LocalDate>()
+            }
+        // SampleEnd
+        val coloredResult = coloredCampaigns.innerJoinWith(coloredVisits, joinExpression = joinExpression)
+        snippetOutput(coloredResult, result)
+    }
+
+    @TransformDataFrameExpressions
+    @Test
+    fun filterJoinWith_strings() {
+        val result =
+            // SampleStart
+            campaigns.filterJoinWith(visits) {
+                right.getValue<LocalDate>("date") in "startDate"<LocalDate>().."endDate"<LocalDate>()
+            }
+        // SampleEnd
+        val coloredResult = coloredCampaigns.filterJoinWith(coloredVisits, joinExpression = joinExpression)
+        snippetOutput(coloredResult, result)
+    }
+
+    @TransformDataFrameExpressions
+    @Test
+    fun leftJoinWith_strings() {
+        val result =
+            // SampleStart
+            campaigns.leftJoinWith(visits) {
+                right.getValue<LocalDate>("date") in "startDate"<LocalDate>().."endDate"<LocalDate>()
+            }
+        // SampleEnd
+        val coloredResult = coloredCampaigns.leftJoinWith(coloredVisits, joinExpression = joinExpression)
+        snippetOutput(coloredResult, result)
+    }
+
+    @TransformDataFrameExpressions
+    @Test
+    fun rightJoinWith_strings() {
+        val result =
+            // SampleStart
+            campaigns.rightJoinWith(visits) {
+                right.getValue<LocalDate>("date") in "startDate"<LocalDate>().."endDate"<LocalDate>()
+            }
+        // SampleEnd
+        val coloredResult = coloredCampaigns.rightJoinWith(coloredVisits, joinExpression = joinExpression)
+        snippetOutput(coloredResult, result)
+    }
+
+    @TransformDataFrameExpressions
+    @Test
+    fun fullJoinWith_strings() {
+        val result =
+            // SampleStart
+            campaigns.fullJoinWith(visits) {
+                right.getValue<LocalDate>("date") in "startDate"<LocalDate>().."endDate"<LocalDate>()
+            }
+        // SampleEnd
+        val coloredResult = coloredCampaigns.fullJoinWith(coloredVisits, joinExpression = joinExpression)
+        snippetOutput(coloredResult, result)
+    }
+
+    @TransformDataFrameExpressions
+    @Test
+    fun excludeJoinWith_strings() {
+        val result =
+            // SampleStart
+            campaigns.excludeJoinWith(visits) {
+                right.getValue<LocalDate>("date") in "startDate"<LocalDate>().."endDate"<LocalDate>()
+            }
+        // SampleEnd
+        val coloredResult = coloredCampaigns.excludeJoinWith(coloredVisits, joinExpression = joinExpression)
+        snippetOutput(coloredResult, result)
+    }
+
+    @TransformDataFrameExpressions
+    @Test
+    fun joinWith_properties() {
+        val result =
+            // SampleStart
+            campaigns.innerJoinWith(visits) {
+                right.date in startDate..endDate
+            }
+        // SampleEnd
+        val coloredResult = coloredCampaigns.innerJoinWith(coloredVisits, joinExpression = joinExpression)
+        snippetOutput(coloredResult, result)
+    }
+
+    @TransformDataFrameExpressions
+    @Test
+    fun filterJoinWith_properties() {
+        val result =
+            // SampleStart
+            campaigns.filterJoinWith(visits) {
+                right.date in startDate..endDate
+            }
+        // SampleEnd
+        val coloredResult = coloredCampaigns.filterJoinWith(coloredVisits, joinExpression = joinExpression)
+        snippetOutput(coloredResult, result)
+    }
+
+    @TransformDataFrameExpressions
+    @Test
+    fun leftJoinWith_properties() {
+        val result =
+            // SampleStart
+            campaigns.leftJoinWith(visits) {
+                right.date in startDate..endDate
+            }
+        // SampleEnd
+        val coloredResult = coloredCampaigns.leftJoinWith(coloredVisits, joinExpression = joinExpression)
+        snippetOutput(coloredResult, result)
+    }
+
+    @TransformDataFrameExpressions
+    @Test
+    fun rightJoinWith_properties() {
+        val result =
+            // SampleStart
+            campaigns.rightJoinWith(visits) {
+                right.date in startDate..endDate
+            }
+        // SampleEnd
+        val coloredResult = coloredCampaigns.rightJoinWith(coloredVisits, joinExpression = joinExpression)
+        snippetOutput(coloredResult, result)
+    }
+
+    @TransformDataFrameExpressions
+    @Test
+    fun fullJoinWith_properties() {
+        val result =
+            // SampleStart
+            campaigns.fullJoinWith(visits) {
+                right.date in startDate..endDate
+            }
+        // SampleEnd
+        val coloredResult = coloredCampaigns.fullJoinWith(coloredVisits, joinExpression = joinExpression)
+        snippetOutput(coloredResult, result)
+    }
+
+    @TransformDataFrameExpressions
+    @Test
+    fun excludeJoinWith_properties() {
+        val result =
+            // SampleStart
+            campaigns.excludeJoinWith(visits) {
+                right.date in startDate..endDate
+            }
+        // SampleEnd
+        val coloredResult = coloredCampaigns.excludeJoinWith(coloredVisits, joinExpression = joinExpression)
+        snippetOutput(coloredResult, result)
+    }
+
+    @TransformDataFrameExpressions
+    @Test
+    fun crossProduct() {
+        val result =
+            // SampleStart
+            campaigns.joinWith(visits) { true }
+        // SampleEnd
+        val coloredResult = coloredCampaigns.joinWith(coloredVisits) { true }
+        snippetOutput(coloredResult, result)
+    }
+
+    val df1 = dataFrameOf("index", "age", "name")(
+        1.spring(), 15.spring(), "BOB".spring(),
+        2.summer(), 19.summer(), "ALICE".summer(),
+        3.autumn(), 20.autumn(), "CHARLIE".autumn(),
+    )
+
+    val df2 = dataFrameOf("index", "age", "name")(
+        1.spring(), 15.spring(), "Bob".spring(),
+        2.summer(), 19.summer(), "Alice".summer(),
+        4.winter(), 21.winter(), "John".winter(),
+    )
+
+    @TransformDataFrameExpressions
+    @Test
+    fun compareInnerColumns() {
+        // SampleStart
+        df1.innerJoin(df2, "index", "age")
+        // SampleEnd
+
+        PluginCallbackProxy.overrideHtmlOutput(
+            manualOutput = DataFrameHtmlData.tableDefinitions()
+                .plus(
+                    DataFrameHtmlData()
+                        .plus(df1.toColoredHTML().wrap("df1"))
+                        .plus(df2.toColoredHTML().wrap("df2"))
+                        .plus(df1.innerJoin(df2, "index", "age").toColoredHTML().wrap("result"))
+                        .wrapRow(),
+                )
+                .plus(other),
+        )
+    }
+
+    @TransformDataFrameExpressions
+    @Test
+    fun compareInnerValues() {
+        // SampleStart
+        df1.innerJoinWith(df2) { it["index"] == right["index"] && it["age"] == right["age"] }
+        // SampleEnd
+
+        PluginCallbackProxy.overrideHtmlOutput(
+            manualOutput = DataFrameHtmlData.tableDefinitions()
+                .plus(
+                    DataFrameHtmlData()
+                        .plus(df1.toColoredHTML().wrap("df1"))
+                        .plus(df2.toColoredHTML().wrap("df2"))
+                        .plus(
+                            df1.innerJoinWith(df2) { it["index"] == right["index"] && it["age"] == right["age"] }
+                                .toColoredHTML().wrap("result")
+                        )
+                        .wrapRow()
+                )
+                .plus(other)
+        )
+    }
+
+    @TransformDataFrameExpressions
+    @Test
+    fun compareLeft() {
+        // SampleStart
+        df1.leftJoin(df2, "index", "age")
+        df1.leftJoinWith(df2) { it["index"] == right["index"] && it["age"] == right["age"] }
+        // SampleEnd
+
+        PluginCallbackProxy.overrideHtmlOutput(
+            manualOutput = DataFrameHtmlData.tableDefinitions()
+                .plus(
+                    DataFrameHtmlData()
+                        .plus(df1.toColoredHTML().wrap("df1"))
+                        .plus(df2.toColoredHTML().wrap("df2"))
+                        .plus(df1.leftJoin(df2, "index", "age").toColoredHTML().wrap("result"))
+                        .wrapRow()
+                )
+                .plus(DataFrameHtmlData(body = "<br><br>"))
+                .plus(
+                    DataFrameHtmlData()
+                        .plus(df1.toColoredHTML().wrap())
+                        .plus(df2.toColoredHTML().wrap())
+                        .plus(
+                            df1.leftJoinWith(df2) { it["index"] == right["index"] && it["age"] == right["age"] }
+                                .toColoredHTML().wrap()
+                        )
+                        .wrapRow()
+                )
+                .plus(other)
+        )
+    }
+
+    @TransformDataFrameExpressions
+    @Test
+    fun compareRight() {
+        // SampleStart
+        df1.rightJoin(df2, "index", "age")
+        df1.rightJoinWith(df2) { it["index"] == right["index"] && it["age"] == right["age"] }
+        // SampleEnd
+
+        PluginCallbackProxy.overrideHtmlOutput(
+            manualOutput = DataFrameHtmlData.tableDefinitions()
+                .plus(
+                    DataFrameHtmlData()
+                        .plus(df1.toColoredHTML().wrap("df1"))
+                        .plus(df2.toColoredHTML().wrap("df2"))
+                        .plus(df1.rightJoin(df2, "index", "age").toColoredHTML().wrap("result"))
+                        .wrapRow()
+                )
+                .plus(DataFrameHtmlData(body = "<br><br>"))
+                .plus(
+                    DataFrameHtmlData()
+                        .plus(df1.toColoredHTML().wrap())
+                        .plus(df2.toColoredHTML().wrap())
+                        .plus(
+                            df1.rightJoinWith(df2) { it["index"] == right["index"] && it["age"] == right["age"] }
+                                .toColoredHTML().wrap()
+                        )
+                        .wrapRow()
+                )
+                .plus(other)
+        )
+    }
+
+    private fun DataFrameHtmlData.wrapRow(): DataFrameHtmlData =
+        copy(
+            body =
+            """
+                <div class="table-row">
+                    $body
+                </div>
+                """.trimIndent(),
+        )
+
+    private val other = DataFrameHtmlData(
+        style =
+        """
+            body {
+                font-family: "JetBrains Mono", SFMono-Regular, Consolas, "Liberation Mono", Menlo, Courier, monospace;
+                font-size: 14px;
+            }
+
+            :root {
+                color: #19191C;
+                background-color: #fff;
+            }
+            
+            :root[theme="dark"] {
+                background-color: #19191C;
+                color: #FFFFFFCC
+            }
+            
+            .table-row {
+                display: flex;
+                align-items: flex-start;
+                overflow-x: auto;
+            }
+            
+            .table-container:not(:last-child) {
+                margin-right: 20px; 
+            }
+            
+            td {
+                white-space: nowrap;
+            }
+            """.trimIndent(),
+    )
+}
diff --git a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/samples/api/Modify.kt b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/samples/api/Modify.kt
new file mode 100644
index 000000000..5929c7ed6
--- /dev/null
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/samples/api/Modify.kt
@@ -0,0 +1,1467 @@
+@file:Suppress("ktlint")
+
+package org.jetbrains.kotlinx.dataframe.samples.api
+
+import io.kotest.matchers.shouldBe
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.DataRow
+import org.jetbrains.kotlinx.dataframe.alsoDebug
+import org.jetbrains.kotlinx.dataframe.annotations.DataSchema
+import org.jetbrains.kotlinx.dataframe.api.ParserOptions
+import org.jetbrains.kotlinx.dataframe.api.add
+import org.jetbrains.kotlinx.dataframe.api.after
+import org.jetbrains.kotlinx.dataframe.api.asFrame
+import org.jetbrains.kotlinx.dataframe.api.asGroupBy
+import org.jetbrains.kotlinx.dataframe.api.at
+import org.jetbrains.kotlinx.dataframe.api.by
+import org.jetbrains.kotlinx.dataframe.api.byName
+import org.jetbrains.kotlinx.dataframe.api.cast
+import org.jetbrains.kotlinx.dataframe.api.castTo
+import org.jetbrains.kotlinx.dataframe.api.colsOf
+import org.jetbrains.kotlinx.dataframe.api.column
+import org.jetbrains.kotlinx.dataframe.api.columnGroup
+import org.jetbrains.kotlinx.dataframe.api.columnOf
+import org.jetbrains.kotlinx.dataframe.api.concat
+import org.jetbrains.kotlinx.dataframe.api.convert
+import org.jetbrains.kotlinx.dataframe.api.convertTo
+import org.jetbrains.kotlinx.dataframe.api.count
+import org.jetbrains.kotlinx.dataframe.api.dataFrameOf
+import org.jetbrains.kotlinx.dataframe.api.default
+import org.jetbrains.kotlinx.dataframe.api.dropNulls
+import org.jetbrains.kotlinx.dataframe.api.explode
+import org.jetbrains.kotlinx.dataframe.api.fill
+import org.jetbrains.kotlinx.dataframe.api.fillNA
+import org.jetbrains.kotlinx.dataframe.api.fillNaNs
+import org.jetbrains.kotlinx.dataframe.api.fillNulls
+import org.jetbrains.kotlinx.dataframe.api.filter
+import org.jetbrains.kotlinx.dataframe.api.flatten
+import org.jetbrains.kotlinx.dataframe.api.gather
+import org.jetbrains.kotlinx.dataframe.api.getRows
+import org.jetbrains.kotlinx.dataframe.api.group
+import org.jetbrains.kotlinx.dataframe.api.groupBy
+import org.jetbrains.kotlinx.dataframe.api.gt
+import org.jetbrains.kotlinx.dataframe.api.implode
+import org.jetbrains.kotlinx.dataframe.api.inplace
+import org.jetbrains.kotlinx.dataframe.api.insert
+import org.jetbrains.kotlinx.dataframe.api.into
+import org.jetbrains.kotlinx.dataframe.api.intoColumns
+import org.jetbrains.kotlinx.dataframe.api.intoList
+import org.jetbrains.kotlinx.dataframe.api.intoRows
+import org.jetbrains.kotlinx.dataframe.api.inward
+import org.jetbrains.kotlinx.dataframe.api.keysInto
+import org.jetbrains.kotlinx.dataframe.api.length
+import org.jetbrains.kotlinx.dataframe.api.lowercase
+import org.jetbrains.kotlinx.dataframe.api.map
+import org.jetbrains.kotlinx.dataframe.api.mapKeys
+import org.jetbrains.kotlinx.dataframe.api.mapToColumn
+import org.jetbrains.kotlinx.dataframe.api.mapToFrame
+import org.jetbrains.kotlinx.dataframe.api.mapValues
+import org.jetbrains.kotlinx.dataframe.api.match
+import org.jetbrains.kotlinx.dataframe.api.max
+import org.jetbrains.kotlinx.dataframe.api.mean
+import org.jetbrains.kotlinx.dataframe.api.meanFor
+import org.jetbrains.kotlinx.dataframe.api.merge
+import org.jetbrains.kotlinx.dataframe.api.minus
+import org.jetbrains.kotlinx.dataframe.api.move
+import org.jetbrains.kotlinx.dataframe.api.named
+import org.jetbrains.kotlinx.dataframe.api.notNull
+import org.jetbrains.kotlinx.dataframe.api.parse
+import org.jetbrains.kotlinx.dataframe.api.parser
+import org.jetbrains.kotlinx.dataframe.api.pathOf
+import org.jetbrains.kotlinx.dataframe.api.perCol
+import org.jetbrains.kotlinx.dataframe.api.perRowCol
+import org.jetbrains.kotlinx.dataframe.api.pivotCounts
+import org.jetbrains.kotlinx.dataframe.api.prev
+import org.jetbrains.kotlinx.dataframe.api.print
+import org.jetbrains.kotlinx.dataframe.api.remove
+import org.jetbrains.kotlinx.dataframe.api.rename
+import org.jetbrains.kotlinx.dataframe.api.reorder
+import org.jetbrains.kotlinx.dataframe.api.replace
+import org.jetbrains.kotlinx.dataframe.api.reverse
+import org.jetbrains.kotlinx.dataframe.api.schema
+import org.jetbrains.kotlinx.dataframe.api.select
+import org.jetbrains.kotlinx.dataframe.api.shuffle
+import org.jetbrains.kotlinx.dataframe.api.sortBy
+import org.jetbrains.kotlinx.dataframe.api.sortByDesc
+import org.jetbrains.kotlinx.dataframe.api.sortWith
+import org.jetbrains.kotlinx.dataframe.api.split
+import org.jetbrains.kotlinx.dataframe.api.sum
+import org.jetbrains.kotlinx.dataframe.api.to
+import org.jetbrains.kotlinx.dataframe.api.toFloat
+import org.jetbrains.kotlinx.dataframe.api.toLeft
+import org.jetbrains.kotlinx.dataframe.api.toMap
+import org.jetbrains.kotlinx.dataframe.api.toPath
+import org.jetbrains.kotlinx.dataframe.api.toTop
+import org.jetbrains.kotlinx.dataframe.api.under
+import org.jetbrains.kotlinx.dataframe.api.unfold
+import org.jetbrains.kotlinx.dataframe.api.ungroup
+import org.jetbrains.kotlinx.dataframe.api.update
+import org.jetbrains.kotlinx.dataframe.api.where
+import org.jetbrains.kotlinx.dataframe.api.with
+import org.jetbrains.kotlinx.dataframe.api.withNull
+import org.jetbrains.kotlinx.dataframe.api.withZero
+import org.jetbrains.kotlinx.dataframe.explainer.PluginCallbackProxy
+import org.jetbrains.kotlinx.dataframe.explainer.TransformDataFrameExpressions
+import org.jetbrains.kotlinx.dataframe.impl.api.mapNotNullValues
+import org.jetbrains.kotlinx.dataframe.indices
+import org.jetbrains.kotlinx.dataframe.io.readJson
+import org.jetbrains.kotlinx.dataframe.io.readJsonStr
+import org.jetbrains.kotlinx.dataframe.io.renderToString
+import org.jetbrains.kotlinx.dataframe.testResource
+import org.jetbrains.kotlinx.dataframe.types.UtilTests
+import org.junit.Ignore
+import org.junit.Test
+import java.net.URL
+import java.time.format.DateTimeFormatter
+import java.util.*
+import kotlin.streams.toList
+
+@Suppress("ktlint:standard:chain-method-continuation", "ktlint:standard:argument-list-wrapping")
+class Modify : TestBase() {
+
+    @Test
+    @TransformDataFrameExpressions
+    fun update() {
+        // SampleStart
+        df.update { age }.with { it * 2 }
+        df.update { colsAtAnyDepth().colsOf<String>() }.with { it.uppercase() }
+        df.update { weight }.at(1..4).notNull { it / 2 }
+        df.update { name.lastName and age }.at(1, 3, 4).withNull()
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun updateWith() {
+        // SampleStart
+        df.update { city }.with { name.firstName + " from " + it }
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun updateWithConst() {
+        // SampleStart
+        df.update { city }.where { name.firstName == "Alice" }.with { "Paris" }
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun updateAsFrame() {
+        val res =
+            // SampleStart
+            df.update { name }.asFrame { select { lastName } }
+        // SampleEnd
+        res shouldBe df.remove { name.firstName }
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun updatePerColumn() {
+        val updated =
+            // SampleStart
+            df.update { colsOf<Number?>() }.perCol { mean(skipNA = true) }
+        // SampleEnd
+        updated.age.countDistinct() shouldBe 1
+        updated.weight.countDistinct() shouldBe 1
+
+        val means = df.meanFor(skipNA = true) { colsOf() }
+        df.update { colsOf<Number?>() }.perCol(means) shouldBe updated
+        df.update { colsOf<Number?>() }.perCol(means.toMap() as Map<String, Double>) shouldBe updated
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun updatePerRowCol() {
+        val updated =
+            // SampleStart
+            df.update { colsOf<String?>() }.perRowCol { row, col -> col.name() + ": " + row.index() }
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun convert() {
+        // SampleStart
+        df.convert { age }.with { it.toDouble() }
+        df.convert { colsAtAnyDepth().colsOf<String>() }.with { it.toCharArray().toList() }
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun convertTo() {
+        // SampleStart
+        df.convert { age }.to<Double>()
+        df.convert { colsOf<Number>() }.to<String>()
+        df.convert { name.firstName and name.lastName }.to { it.length() }
+        df.convert { weight }.toFloat()
+        // SampleEnd
+    }
+
+    enum class Direction {
+        NORTH,
+        SOUTH,
+        WEST,
+        EAST,
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun convertToEnum() {
+        // SampleStart
+        dataFrameOf("direction")("NORTH", "WEST")
+            .convert("direction").to<Direction>()
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun convertAsFrame() {
+        // SampleStart
+        df.convert { name }.asFrame { it.add("fullName") { "$firstName $lastName" } }
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun parseAll() {
+        // SampleStart
+        df.parse()
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun parseSome() {
+        // SampleStart
+        df.parse { age and weight }
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun parseWithOptions() {
+        // SampleStart
+        df.parse(options = ParserOptions(locale = Locale.CHINA, dateTimeFormatter = DateTimeFormatter.ISO_WEEK_DATE))
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun globalParserOptions() {
+        // SampleStart
+        DataFrame.parser.locale = Locale.FRANCE
+        DataFrame.parser.addDateTimePattern("dd.MM.uuuu HH:mm:ss")
+        // SampleEnd
+        DataFrame.parser.resetToDefault()
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun replace() {
+        // SampleStart
+        df.replace { name }.with { name.firstName }
+        df.replace { colsOf<String?>() }.with { it.lowercase() }
+        df.replace { age }.with { 2021 - age named "year" }
+        // SampleEnd
+    }
+
+    @Test
+    fun shuffle() {
+        // SampleStart
+        df.shuffle()
+        // SampleEnd
+
+        PluginCallbackProxy.expressionsByStatement[0] = listOf(
+            PluginCallbackProxy.Expression(
+                source = "df",
+                containingClassFqName = "org.jetbrains.kotlinx.dataframe.samples.api.Modify",
+                containingFunName = "shuffle",
+                df = df,
+            ),
+            PluginCallbackProxy.Expression(
+                source = "shuffle()",
+                containingClassFqName = "org.jetbrains.kotlinx.dataframe.samples.api.Modify",
+                containingFunName = "shuffle",
+                df = df.getRows(df.indices.shuffled(Random(123))),
+            ),
+        )
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun reverse() {
+        // SampleStart
+        df.reverse()
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun fillNulls() {
+        // SampleStart
+        df.fillNulls { colsOf<Int?>() }.with { -1 }
+        // same as
+        df.update { colsOf<Int?>() }.where { it == null }.with { -1 }
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun fillNaNs() {
+        // SampleStart
+        df.fillNaNs { colsOf<Double>() }.withZero()
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun fillNA() {
+        // SampleStart
+        df.fillNA { weight }.with { -1 }
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun move() {
+        // SampleStart
+        df.move { age }.toLeft()
+
+        df.move { weight }.to(1)
+
+        // age -> info.age
+        // weight -> info.weight
+        df.move { age and weight }.into { pathOf("info", it.name()) }
+        df.move { age and weight }.into { "info"[it.name()] }
+        df.move { age and weight }.under("info")
+
+        // name.firstName -> fullName.first
+        // name.lastName -> fullName.last
+        df.move { name.firstName and name.lastName }.into { pathOf("fullName", it.name().dropLast(4)) }
+
+        // a|b|c -> a.b.c
+        // a|d|e -> a.d.e
+        dataFrameOf("a|b|c", "a|d|e")(0, 0)
+            .move { all() }.into { it.name().split("|").toPath() }
+
+        // name.firstName -> firstName
+        // name.lastName -> lastName
+        df.move { name.cols() }.toTop()
+
+        // a.b.e -> be
+        // c.d.e -> de
+        df.move { colsAtAnyDepth { it.name() == "e" } }.toTop { it.parentName + it.name() }
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun sortBy_properties() {
+        // SampleStart
+        df.sortBy { age }
+        df.sortBy { age and name.firstName.desc() }
+        df.sortBy { weight.nullsLast() }
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun sortBy_accessors() {
+        // SampleStart
+        val age by column<Int>()
+        val weight by column<Int?>()
+        val name by columnGroup()
+        val firstName by name.column<String>()
+
+        df.sortBy { age }
+        df.sortBy { age and firstName }
+        df.sortBy { weight.nullsLast() }
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun sortBy_strings() {
+        // SampleStart
+        df.sortBy("age")
+        df.sortBy { "age" and "name"["firstName"].desc() }
+        df.sortBy { "weight".nullsLast() }
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun sortByDesc_properties() {
+        // SampleStart
+        df.sortByDesc { age and weight }
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun sortByDesc_accessors() {
+        // SampleStart
+        val age by column<Int>()
+        val weight by column<Int?>()
+
+        df.sortByDesc { age and weight }
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun sortByDesc_strings() {
+        // SampleStart
+        df.sortByDesc("age", "weight")
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun sortWith() {
+        // SampleStart
+        df.sortWith { row1, row2 ->
+            when {
+                row1.age < row2.age -> -1
+                row1.age > row2.age -> 1
+                else -> row1.name.firstName.compareTo(row2.name.firstName)
+            }
+        }
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun reorder_properties() {
+        // SampleStart
+        df.reorder { age..isHappy }.byName()
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun reorder_accessors() {
+        // SampleStart
+        val age by column<Int>()
+        val isHappy by column<Boolean>()
+
+        df.reorder { age..isHappy }.byName()
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun reorder_strings() {
+        // SampleStart
+        df.reorder { "age".."isHappy" }.byName()
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun reorderSome() {
+        // SampleStart
+        val df = dataFrameOf("c", "d", "a", "b")(
+            3, 4, 1, 2,
+            1, 1, 1, 1,
+        )
+        df.reorder("d", "b").cast<Int>().by { sum() } // [c, b, a, d]
+            // SampleEnd
+            .columnNames() shouldBe listOf("c", "b", "a", "d")
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun reorderInGroup() {
+        // SampleStart
+        df.reorder { name }.byName(desc = true) // [name.lastName, name.firstName]
+            // SampleEnd
+            .name.columnNames() shouldBe listOf("lastName", "firstName")
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun splitInplace_properties() {
+        // SampleStart
+        df.split { name.firstName }.by { it.asIterable() }.inplace()
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun splitInplace_accessors() {
+        // SampleStart
+        val name by columnGroup()
+        val firstName by name.column<String>()
+
+        df.split { firstName }.by { it.asIterable() }.inplace()
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun splitInplace_strings() {
+        // SampleStart
+        df.split { "name"["firstName"]<String>() }.by { it.asIterable() }.inplace()
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun split_properties() {
+        // SampleStart
+        df.split { name.lastName }.by { it.asIterable() }.into("char1", "char2")
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun split_accessors() {
+        // SampleStart
+        val name by columnGroup()
+        val lastName by name.column<String>()
+
+        df.split { lastName }.by { it.asIterable() }.into("char1", "char2")
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun split_strings() {
+        // SampleStart
+        df.split { "name"["lastName"]<String>() }.by { it.asIterable() }.into("char1", "char2")
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun split1_properties() {
+        // SampleStart
+        df.split { name.lastName }
+            .by { it.asIterable() }.default(' ')
+            .inward { "char$it" }
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun split1_accessors() {
+        // SampleStart
+        val name by columnGroup()
+        val lastName by name.column<String>()
+
+        df.split { lastName }
+            .by { it.asIterable() }.default(' ')
+            .inward { "char$it" }
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun split1_strings() {
+        // SampleStart
+        df.split { "name"["lastName"]<String>() }
+            .by { it.asIterable() }.default(' ')
+            .inward { "char$it" }
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun splitRegex() {
+        // SampleStart
+        val merged = df.merge { name.lastName and name.firstName }
+            .by { it[0] + " (" + it[1] + ")" }
+            .into("name")
+        // SampleEnd
+    }
+
+    private val merged = df.merge { name.lastName and name.firstName }.by { it[0] + " (" + it[1] + ")" }.into("name")
+
+    @Test
+    @TransformDataFrameExpressions
+    fun splitRegex1() {
+        // SampleStart
+        val name by column<String>()
+
+        merged.split { name }
+            .match("""(.*) \((.*)\)""")
+            .inward("firstName", "lastName")
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun splitFrameColumn() {
+        // SampleStart
+        val df1 = dataFrameOf("a", "b", "c")(
+            1, 2, 3,
+            4, 5, 6,
+        )
+        val df2 = dataFrameOf("a", "b")(
+            5, 6,
+            7, 8,
+            9, 10,
+        )
+        val group by columnOf(df1, df2)
+        val id by columnOf("x", "y")
+        val df = dataFrameOf(id, group)
+
+        df.split { group }.intoColumns()
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun splitIntoRows_properties() {
+        // SampleStart
+        df.split { name.firstName }.by { it.asIterable() }.intoRows()
+
+        df.split { name }.by { it.values() }.intoRows()
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun splitIntoRows_accessors() {
+        // SampleStart
+        val name by columnGroup()
+        val firstName by name.column<String>()
+
+        df.split { firstName }.by { it.asIterable() }.intoRows()
+
+        df.split { name }.by { it.values() }.intoRows()
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun splitIntoRows_strings() {
+        // SampleStart
+        df.split { "name"["firstName"]<String>() }.by { it.asIterable() }.intoRows()
+
+        df.split { colGroup("name") }.by { it.values() }.intoRows()
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun merge() {
+        // SampleStart
+        // Merge two columns into one column "fullName"
+        df.merge { name.firstName and name.lastName }.by(" ").into("fullName")
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun mergeIntoList() {
+        // SampleStart
+        // Merge data from two columns into List<String>
+        df.merge { name.firstName and name.lastName }.by(",").intoList()
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun mergeSameWith() {
+        // SampleStart
+        df.merge { name.firstName and name.lastName }
+            .by { it[0] + " (" + it[1].uppercase() + ")" }
+            .into("fullName")
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun mergeDifferentWith() {
+        // SampleStart
+        df.merge { name.firstName and age and isHappy }
+            .by { "${it[0]} aged ${it[1]} is " + (if (it[2] as Boolean) "" else "not ") + "happy" }
+            .into("status")
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun mergeDefault() {
+        // SampleStart
+        df.merge { colsOf<Number>() }.into("data")
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun explode_accessors() {
+        // SampleStart
+        val a by columnOf(1, 2)
+        val b by columnOf(listOf(1, 2), listOf(3, 4))
+
+        val df = dataFrameOf(a, b)
+
+        df.explode { b }
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun explode_strings() {
+        // SampleStart
+        val df = dataFrameOf("a", "b")(
+            1, listOf(1, 2),
+            2, listOf(3, 4),
+        )
+
+        df.explode("b")
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun explodeSeveral() {
+        // SampleStart
+        val a by columnOf(listOf(1, 2), listOf(3, 4, 5))
+        val b by columnOf(listOf(1, 2, 3), listOf(4, 5))
+
+        val df = dataFrameOf(a, b)
+        df.explode { a and b }
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun explodeColumnList() {
+        // SampleStart
+        val col by columnOf(listOf(1, 2), listOf(3, 4))
+
+        col.explode()
+        // SampleEnd
+    }
+
+    //    @TransformDataFrameExpressions
+    @Test
+    fun explodeColumnFrames() {
+        // SampleStart
+        val col by columnOf(
+            dataFrameOf("a", "b")(1, 2, 3, 4),
+            dataFrameOf("a", "b")(5, 6, 7, 8),
+        )
+
+        col.explode()
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun implode() {
+        // SampleStart
+        df.implode { name and age and weight and isHappy }
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun gatherNames() {
+        val pivoted = df.dropNulls { city }.pivotCounts(inward = false) { city }
+        // SampleStart
+        pivoted.gather { "London".."Tokyo" }.cast<Int>()
+            .where { it > 0 }.keysInto("city")
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun gather() {
+        val pivoted = df.dropNulls { city }.pivotCounts(inward = false) { city }
+        // SampleStart
+        pivoted.gather { "London".."Tokyo" }.into("city", "population")
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun gatherWithMapping() {
+        val pivoted = df.dropNulls { city }.pivotCounts(inward = false) { city }
+        // SampleStart
+        pivoted.gather { "London".."Tokyo" }
+            .cast<Int>()
+            .where { it > 10 }
+            .mapKeys { it.lowercase() }
+            .mapValues { 1.0 / it }
+            .into("city", "density")
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun insert_properties() {
+        // SampleStart
+        df.insert("year of birth") { 2021 - age }.after { age }
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun insert_accessors() {
+        // SampleStart
+        val year = column<Int>("year of birth")
+        val age by column<Int>()
+
+        df.insert(year) { 2021 - age }.after { age }
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun insert_strings() {
+        // SampleStart
+        df.insert("year of birth") { 2021 - "age"<Int>() }.after("age")
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun insertColumn() {
+        // SampleStart
+        val score by columnOf(4, 5, 3, 5, 4, 5, 3)
+        df.insert(score).at(2)
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun concatDataFrames() {
+        val df1 = df
+        val df2 = df
+        // SampleStart
+        df.concat(df1, df2)
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun concatColumns() {
+        // SampleStart
+        val a by columnOf(1, 2)
+        val b by columnOf(3, 4)
+        a.concat(b)
+            // SampleEnd
+            .shouldBe(columnOf(1, 2, 3, 4).named("a"))
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun concatColumnsIterable() {
+        // SampleStart
+        val a by columnOf(1, 2)
+        val b by columnOf(3, 4)
+        listOf(a, b).concat()
+            // SampleEnd
+            .shouldBe(columnOf(1, 2, 3, 4).named("a"))
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun concatIterable() {
+        val df1 = df
+        val df2 = df
+        // SampleStart
+        listOf(df1, df2).concat()
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun concatRows() {
+        // SampleStart
+        val rows = listOf(df[2], df[4], df[5])
+        rows.concat()
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun concatFrameColumn() {
+        // SampleStart
+        val x = dataFrameOf("a", "b")(
+            1, 2,
+            3, 4,
+        )
+        val y = dataFrameOf("b", "c")(
+            5, 6,
+            7, 8,
+        )
+        val frameColumn by columnOf(x, y)
+        frameColumn.concat()
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun concatGroupBy() {
+        // SampleStart
+        df.groupBy { name }.concat()
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun add_properties() {
+        // SampleStart
+        df.add("year of birth") { 2021 - age }
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun add_accessors() {
+        // SampleStart
+        val age by column<Int>()
+        val yearOfBirth by column<Int>("year of birth")
+
+        df.add(yearOfBirth) { 2021 - age }
+        // SampleEnd
+        val added = df.add(yearOfBirth) { 2021 - age }
+        added[yearOfBirth].name() shouldBe "year of birth"
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun add_strings() {
+        // SampleStart
+        df.add("year of birth") { 2021 - "age"<Int>() }
+        // SampleEnd
+    }
+
+    @Suppress("ktlint:standard:multiline-if-else", "ktlint:standard:if-else-wrapping")
+    @Test
+    @TransformDataFrameExpressions
+    fun addRecurrent() {
+        // SampleStart
+        df.add("fibonacci") {
+            if (index() < 2) 1
+            else prev()!!.newValue<Int>() + prev()!!.prev()!!.newValue<Int>()
+        }
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun addExisting() {
+        // SampleStart
+        val score by columnOf(4, 3, 5, 2, 1, 3, 5)
+
+        df.add(score)
+        df + score
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun addDataFrames() {
+        val df1 = df.select { name named "name2" }
+        val df2 = df.select { age named "age2" }
+        // SampleStart
+        df.add(df1, df2)
+        // SampleEnd
+    }
+
+    private class CityInfo(val city: String?, val population: Int, val location: String)
+
+    private fun queryCityInfo(city: String?): CityInfo = CityInfo(city, city?.length ?: 0, "35.5 32.2")
+
+    @Test
+    @TransformDataFrameExpressions
+    fun addCalculatedApi() {
+        // SampleStart
+        class CityInfo(val city: String?, val population: Int, val location: String)
+
+        fun queryCityInfo(city: String?): CityInfo = CityInfo(city, city?.length ?: 0, "35.5 32.2")
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun addCalculated_properties() {
+        // SampleStart
+        val personWithCityInfo = df.add {
+            val cityInfo = city.map { queryCityInfo(it) }
+            "cityInfo" {
+                cityInfo.map { it.location } into CityInfo::location
+                cityInfo.map { it.population } into "population"
+            }
+        }
+        // SampleEnd
+        personWithCityInfo["cityInfo"]["population"] shouldBe df.city.map { it?.length ?: 0 }.named("population")
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun addCalculated_accessors() {
+        // SampleStart
+        val city by column<String?>()
+        val personWithCityInfo = df.add {
+            val cityInfo = city().map { queryCityInfo(it) }
+            "cityInfo" {
+                cityInfo.map { it.location } into CityInfo::location
+                cityInfo.map { it.population } into "population"
+            }
+        }
+        // SampleEnd
+        personWithCityInfo["cityInfo"]["population"] shouldBe df.city.map { it?.length ?: 0 }.named("population")
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun addCalculated_strings() {
+        // SampleStart
+        val personWithCityInfo = df.add {
+            val cityInfo = "city"<String?>().map { queryCityInfo(it) }
+            "cityInfo" {
+                cityInfo.map { it.location } into CityInfo::location
+                cityInfo.map { it.population } into "population"
+            }
+        }
+        // SampleEnd
+        personWithCityInfo["cityInfo"]["population"] shouldBe df.city.map { it?.length ?: 0 }.named("population")
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun addMany_properties() {
+        // SampleStart
+        df.add {
+            "year of birth" from 2021 - age
+            age gt 18 into "is adult"
+            "details" {
+                name.lastName.length() into "last name length"
+                "full name" from { name.firstName + " " + name.lastName }
+            }
+        }
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun addMany_accessors() {
+        // SampleStart
+        val yob = column<Int>("year of birth")
+        val lastNameLength = column<Int>("last name length")
+        val age by column<Int>()
+        val isAdult = column<Boolean>("is adult")
+        val fullName = column<String>("full name")
+        val name by columnGroup()
+        val details by columnGroup()
+        val firstName by name.column<String>()
+        val lastName by name.column<String>()
+
+        df.add {
+            yob from 2021 - age
+            age gt 18 into isAdult
+            details from {
+                lastName.length() into lastNameLength
+                fullName from { firstName() + " " + lastName() }
+            }
+        }
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun addMany_strings() {
+        // SampleStart
+        df.add {
+            "year of birth" from 2021 - "age"<Int>()
+            "age"<Int>() gt 18 into "is adult"
+            "details" {
+                "name"["lastName"]<String>().length() into "last name length"
+                "full name" from { "name"["firstName"]<String>() + " " + "name"["lastName"]<String>() }
+            }
+        }
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun remove_properties() {
+        // SampleStart
+        df.remove { name and weight }
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun remove_accessors() {
+        // SampleStart
+        val name by columnGroup()
+        val weight by column<Int?>()
+
+        df.remove { name and weight }
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun remove_strings() {
+        // SampleStart
+        df.remove("name", "weight")
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun map() {
+        // SampleStart
+        df.map { 2021 - it.age }
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun mapToColumn_properties() {
+        // SampleStart
+        df.mapToColumn("year of birth") { 2021 - age }
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun mapToColumn_accessors() {
+        // SampleStart
+        val age by column<Int>()
+        val yearOfBirth by column<Int>("year of birth")
+
+        df.mapToColumn(yearOfBirth) { 2021 - age }
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun mapToColumn_strings() {
+        // SampleStart
+        df.mapToColumn("year of birth") { 2021 - "age"<Int>() }
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun mapMany_properties() {
+        // SampleStart
+        df.mapToFrame {
+            "year of birth" from 2021 - age
+            age gt 18 into "is adult"
+            name.lastName.length() into "last name length"
+            "full name" from { name.firstName + " " + name.lastName }
+            +city
+        }
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun mapMany_accessors() {
+        // SampleStart
+        val yob = column<Int>("year of birth")
+        val lastNameLength = column<Int>("last name length")
+        val age by column<Int>()
+        val isAdult = column<Boolean>("is adult")
+        val fullName = column<String>("full name")
+        val name by columnGroup()
+        val firstName by name.column<String>()
+        val lastName by name.column<String>()
+        val city by column<String?>()
+
+        df.mapToFrame {
+            yob from 2021 - age
+            age gt 18 into isAdult
+            lastName.length() into lastNameLength
+            fullName from { firstName() + " " + lastName() }
+            +city
+        }
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun mapMany_strings() {
+        // SampleStart
+        df.mapToFrame {
+            "year of birth" from 2021 - "age"<Int>()
+            "age"<Int>() gt 18 into "is adult"
+            "name"["lastName"]<String>().length() into "last name length"
+            "full name" from { "name"["firstName"]<String>() + " " + "name"["lastName"]<String>() }
+            +"city"
+        }
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun group() {
+        // SampleStart
+        df.group { age and city }.into("info")
+
+        df.group { all() }.into { it.type().toString() }.print()
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun ungroup() {
+        // SampleStart
+        // name.firstName -> firstName
+        // name.lastName -> lastName
+        df.ungroup { name }
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun flatten_properties() {
+        // SampleStart
+        // name.firstName -> firstName
+        // name.lastName -> lastName
+        df.flatten { name }
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun flatten_strings() {
+        // SampleStart
+        // name.firstName -> firstName
+        // name.lastName -> lastName
+        df.flatten("name")
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun flatten_accessors() {
+        // SampleStart
+        val name by columnGroup()
+        val firstName by name.column<String>()
+        val lastName by name.column<String>()
+        // name.firstName -> firstName
+        // name.lastName -> lastName
+        df.flatten(name)
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun flatten_KProperties() {
+        // SampleStart
+        // name.firstName -> firstName
+        // name.lastName -> lastName
+        df.flatten(df::name)
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun flattenAll() {
+        // SampleStart
+        df.flatten()
+        // SampleEnd
+    }
+
+    // @TransformDataFrameExpressions
+    @Test
+    fun multiCallOperations() {
+        // SampleStart
+        df.update { age }.where { city == "Paris" }.with { it - 5 }
+            .filter { isHappy && age > 100 }
+            .move { name.firstName and name.lastName }.after { isHappy }
+            .merge { age and weight }.by { "Age: ${it[0]}, weight: ${it[1]}" }.into("info")
+            .rename { isHappy }.into("isOK")
+        // SampleEnd
+    }
+
+    class MyType(val value: Int)
+
+    @DataSchema
+    class MySchema(val a: MyType, val b: MyType, val c: Int)
+
+    fun customConvertersData() {
+        // SampleStart
+        class MyType(val value: Int)
+
+        @DataSchema
+        class MySchema(val a: MyType, val b: MyType, val c: Int)
+
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun customConverters() {
+        // SampleStart
+        val df = dataFrameOf("a", "b")(1, "2")
+        df.convertTo<MySchema> {
+            convert<Int>().with { MyType(it) } // converts `a` from Int to MyType
+            parser { MyType(it.toInt()) } // converts `b` from String to MyType
+            fill { c }.with { a.value + b.value } // computes missing column `c`
+        }
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun convertToColumnGroupUseCase() {
+        // SampleStart
+        class RepositoryInfo(val data: Any)
+
+        fun downloadRepositoryInfo(url: String) = RepositoryInfo("fancy response from the API")
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun convertToColumnGroupData() {
+        class RepositoryInfo(val data: Any)
+
+        fun downloadRepositoryInfo(url: String) = RepositoryInfo("fancy response from the API")
+
+        // SampleStart
+        val interestingRepos = dataFrameOf("name", "url")(
+            "dataframe", "/dataframe",
+            "kotlin", "/kotlin",
+        )
+
+        val initialData = interestingRepos
+            .add("response") { downloadRepositoryInfo("url"<String>()) }
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun convertToColumnGroup() {
+        class RepositoryInfo(val data: Any)
+
+        fun downloadRepositoryInfo(url: String) = RepositoryInfo("fancy response from the API")
+
+        val interestingRepos = dataFrameOf("name", "url")(
+            "dataframe", "/dataframe",
+            "kotlin", "/kotlin",
+        )
+
+        val initialData = interestingRepos
+            .add("response") { downloadRepositoryInfo("url"()) }
+
+        // SampleStart
+        val df = initialData.unfold("response")
+        // SampleEnd
+        df.schema().print()
+    }
+
+    @DataSchema
+    interface Df {
+        val response: DataRow<Response>
+    }
+
+    @DataSchema
+    interface Response {
+        val data: Any
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun convertToColumnGroupBenefits() {
+        class RepositoryInfo(val data: Any)
+
+        fun downloadRepositoryInfo(url: String) = RepositoryInfo("fancy response from the API")
+
+        val interestingRepos = dataFrameOf("name", "url")(
+            "dataframe", "/dataframe",
+            "kotlin", "/kotlin",
+        )
+
+        val initialData = interestingRepos
+            .add("response") { downloadRepositoryInfo("url"()) }
+
+        val df = initialData.unfold("response").cast<Df>()
+
+        // SampleStart
+        df.move { response.data }.toTop()
+        df.rename { response.data }.into("description")
+        // SampleEnd
+
+        df.move { response.data }.toTop().alsoDebug()
+        df.rename { response.data }.into("description").alsoDebug()
+    }
+
+    @Ignore
+    @Test
+    @TransformDataFrameExpressions
+    fun convertToFrameColumnAPI() {
+        // SampleStart
+        fun testResource(resourcePath: String): URL = UtilTests::class.java.classLoader.getResource(resourcePath)!!
+
+        val interestingRepos = dataFrameOf("name", "url", "contributors")(
+            "dataframe", "/dataframe", testResource("dataframeContributors.json"),
+            "kotlin", "/kotlin", testResource("kotlinContributors.json"),
+        )
+        // SampleEnd
+    }
+
+    @Ignore
+    @Test
+    @TransformDataFrameExpressions
+    fun customUnfoldRead() {
+        val interestingRepos = dataFrameOf("name", "url", "contributors")(
+            "dataframe", "/dataframe", testResource("dataframeContributors.json"),
+            "kotlin", "/kotlin", testResource("kotlinContributors.json"),
+        )
+
+        // SampleStart
+        val contributors by column<URL>()
+
+        val df = interestingRepos
+            .replace { contributors }
+            .with {
+                it.mapNotNullValues { url -> DataFrame.readJsonStr(url.readText()) }
+            }
+
+        df.asGroupBy("contributors").max("contributions")
+        // SampleEnd
+
+        df.asGroupBy("contributors").max("contributions").renderToString() shouldBe
+            """|        name        url contributions
+               | 0 dataframe /dataframe           111
+               | 1    kotlin    /kotlin           180
+            """.trimMargin()
+    }
+
+    @DataSchema
+    interface ImplicitSchema {
+        val perf: Double
+    }
+
+    @Test
+    @Ignore
+    @Suppress("UNUSED_VARIABLE")
+    fun castToGenerateSchema() {
+        // SampleStart
+        val sample = DataFrame.readJson("sample.json")
+        // SampleEnd
+    }
+
+    @Test
+    @Suppress("KotlinConstantConditions")
+    fun castTo() {
+        val sample = dataFrameOf("perf")(10.0, 20.0, 12.0).cast<ImplicitSchema>()
+        val files = listOf<String>() // not intended to run
+        // SampleStart
+        for (file in files) {
+            // df here is expected to have the same structure as sample
+            val df = DataFrame.readJson(file).castTo(sample)
+            val count = df.count { perf > 10.0 }
+            println("$file: $count")
+        }
+        // SampleEnd
+    }
+}
diff --git a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/samples/api/OtherSamples.kt b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/samples/api/OtherSamples.kt
new file mode 100644
index 000000000..b598f9a08
--- /dev/null
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/samples/api/OtherSamples.kt
@@ -0,0 +1,28 @@
+package org.jetbrains.kotlinx.dataframe.samples.api
+
+import org.jetbrains.kotlinx.dataframe.AnyFrame
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.api.take
+import org.jetbrains.kotlinx.dataframe.explainer.WritersideFooter
+import org.jetbrains.kotlinx.dataframe.explainer.WritersideStyle
+import org.jetbrains.kotlinx.dataframe.io.readCSV
+import org.jetbrains.kotlinx.dataframe.io.toStandaloneHTML
+import org.junit.Test
+import java.io.File
+
+// To display code together with a table, we can use TransformDataFrameExpressions annotation together with korro
+// This class provides an ability to save only a table that can be embedded anywhere in the documentation
+class OtherSamples {
+
+    @Test
+    fun example() {
+        val df = DataFrame.readCSV("../data/titanic.csv", delimiter = ';').take(5)
+        // writeTable(df, "exampleName")
+    }
+
+    private fun writeTable(df: AnyFrame, name: String) {
+        val dir = File("../docs/StardustDocs/snippets/manual").also { it.mkdirs() }
+        val html = df.toStandaloneHTML(getFooter = WritersideFooter) + WritersideStyle
+        html.writeHTML(File(dir, "$name.html"))
+    }
+}
diff --git a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/samples/api/Render.kt b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/samples/api/Render.kt
new file mode 100644
index 000000000..dac7405fe
--- /dev/null
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/samples/api/Render.kt
@@ -0,0 +1,48 @@
+@file:Suppress("ktlint")
+
+package org.jetbrains.kotlinx.dataframe.samples.api
+
+import org.jetbrains.kotlinx.dataframe.api.reorderColumnsByName
+import org.jetbrains.kotlinx.dataframe.api.sortBy
+import org.jetbrains.kotlinx.dataframe.api.sortByDesc
+import org.jetbrains.kotlinx.dataframe.explainer.TransformDataFrameExpressions
+import org.jetbrains.kotlinx.dataframe.io.DataFrameHtmlData
+import org.jetbrains.kotlinx.dataframe.io.DisplayConfiguration
+import org.jetbrains.kotlinx.dataframe.io.toHTML
+import org.jetbrains.kotlinx.dataframe.io.toStandaloneHTML
+import org.junit.Ignore
+import org.junit.Test
+import java.io.File
+import kotlin.io.path.Path
+
+class Render : TestBase() {
+    @Test
+    @TransformDataFrameExpressions
+    @Ignore
+    fun useRenderingResult() {
+        // SampleStart
+        df.toStandaloneHTML(DisplayConfiguration(rowsLimit = null)).openInBrowser()
+        df.toStandaloneHTML(DisplayConfiguration(rowsLimit = null)).writeHTML(File("/path/to/file"))
+        df.toStandaloneHTML(DisplayConfiguration(rowsLimit = null)).writeHTML(Path("/path/to/file"))
+        // SampleEnd
+    }
+
+    @Test
+    fun composeTables() {
+        // SampleStart
+        val df1 = df.reorderColumnsByName()
+        val df2 = df.sortBy { age }
+        val df3 = df.sortByDesc { age }
+
+        listOf(df1, df2, df3).fold(DataFrameHtmlData.tableDefinitions()) { acc, df -> acc + df.toHTML() }
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun configureCellOutput() {
+        // SampleStart
+        df.toHTML(DisplayConfiguration(cellContentLimit = -1))
+        // SampleEnd
+    }
+}
diff --git a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/samples/api/Schemas.kt b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/samples/api/Schemas.kt
new file mode 100644
index 000000000..1eecc0475
--- /dev/null
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/samples/api/Schemas.kt
@@ -0,0 +1,138 @@
+@file:Suppress("ktlint")
+
+package org.jetbrains.kotlinx.dataframe.samples.api
+
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.annotations.DataSchema
+import org.jetbrains.kotlinx.dataframe.api.by
+import org.jetbrains.kotlinx.dataframe.api.cast
+import org.jetbrains.kotlinx.dataframe.api.count
+import org.jetbrains.kotlinx.dataframe.api.dataFrameOf
+import org.jetbrains.kotlinx.dataframe.api.filter
+import org.jetbrains.kotlinx.dataframe.api.inward
+import org.jetbrains.kotlinx.dataframe.api.maxBy
+import org.jetbrains.kotlinx.dataframe.api.print
+import org.jetbrains.kotlinx.dataframe.api.split
+import org.jetbrains.kotlinx.dataframe.api.toList
+import org.jetbrains.kotlinx.dataframe.explainer.TransformDataFrameExpressions
+import org.junit.Test
+
+@Suppress("ktlint:standard:argument-list-wrapping")
+class Schemas {
+
+    @DataSchema
+    interface Person {
+        val name: String
+        val age: Int
+    }
+
+    fun DataFrame<Person>.splitName() = split { name }.by(",").inward("firstName", "lastName")
+
+    fun DataFrame<Person>.adults() = filter { age > 18 }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun createDfNullable() {
+        // SampleStart
+        val df = dataFrameOf("name", "age")(
+            "Alice", 15,
+            "Bob", null,
+        )
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun createDf() {
+        // SampleStart
+        val df = dataFrameOf("name", "age")(
+            "Alice", 15,
+            "Bob", 20,
+        )
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun extendedDf() {
+        // SampleStart
+        val df = dataFrameOf("name", "age", "weight")(
+            "Merton, Alice", 15, 60.0,
+            "Marley, Bob", 20, 73.5,
+        )
+        // SampleEnd
+        df.print()
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun splitNameWorks() {
+        val df = dataFrameOf("name", "age", "weight")(
+            "Merton, Alice", 15, 60.0,
+            "Marley, Bob", 20, 73.5,
+        ).cast<Person>()
+        // SampleStart
+        df.splitName()
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun adultsWorks() {
+        val df = dataFrameOf("name", "age", "weight")(
+            "Merton, Alice", 15, 60.0,
+            "Marley, Bob", 20, 73.5,
+        ).cast<Person>()
+        // SampleStart
+        df.adults()
+        // SampleEnd
+    }
+
+    fun DataFrame<Person>.countAdults() = count { it[Person::age] > 18 }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun convertTo() {
+        // SampleStart
+        @DataSchema
+        data class Name(val firstName: String, val lastName: String)
+
+        @DataSchema
+        data class Person(val name: Name, val age: Int?)
+
+        val df = dataFrameOf("name", "age", "weight")(
+            "Merton, Alice", "15", 60.0,
+            "Marley, Bob", "20", 73.5,
+        ).split { "name"<String>() }.inward("firstName", "lastName")
+
+        val persons = df.cast<Person>().toList()
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun useProperties() {
+        // SampleStart
+        val df = dataFrameOf("name", "age")(
+            "Alice", 15,
+            "Bob", 20,
+        ).cast<Person>()
+        // age only available after executing `build` or `kspKotlin`!
+        val teens = df.filter { age in 10..19 }
+        teens.print()
+        // SampleEnd
+    }
+
+    @Test
+    @TransformDataFrameExpressions
+    fun useInferredSchema() {
+        // SampleStart
+        // Repository.readCSV() has argument 'path' with default value https://raw.githubusercontent.com/Kotlin/dataframe/master/data/jetbrains_repositories.csv
+        val df = Repository.readCSV()
+        // Use generated properties to access data in rows
+        df.maxBy { stargazersCount }.print()
+        // Or to access columns in dataframe.
+        print(df.fullName.count { it.contains("kotlin") })
+        // SampleEnd
+    }
+}
diff --git a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/samples/api/TestBase.kt b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/samples/api/TestBase.kt
new file mode 100644
index 000000000..21accfbd8
--- /dev/null
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/samples/api/TestBase.kt
@@ -0,0 +1,156 @@
+@file:Suppress("ktlint")
+
+package org.jetbrains.kotlinx.dataframe.samples.api
+
+import io.kotest.matchers.should
+import io.kotest.matchers.shouldBe
+import io.kotest.matchers.shouldNotBe
+import org.jetbrains.kotlinx.dataframe.DataRow
+import org.jetbrains.kotlinx.dataframe.annotations.DataSchema
+import org.jetbrains.kotlinx.dataframe.api.asColumnGroup
+import org.jetbrains.kotlinx.dataframe.api.cast
+import org.jetbrains.kotlinx.dataframe.api.convert
+import org.jetbrains.kotlinx.dataframe.api.dataFrameOf
+import org.jetbrains.kotlinx.dataframe.api.group
+import org.jetbrains.kotlinx.dataframe.api.into
+import org.jetbrains.kotlinx.dataframe.api.isValueColumn
+import org.jetbrains.kotlinx.dataframe.api.map
+import org.jetbrains.kotlinx.dataframe.api.print
+import org.jetbrains.kotlinx.dataframe.api.to
+import org.jetbrains.kotlinx.dataframe.columns.ColumnWithPath
+import org.jetbrains.kotlinx.dataframe.explainer.PluginCallbackProxy
+import org.jetbrains.kotlinx.dataframe.impl.columns.asValueColumn
+import org.junit.After
+import org.junit.Before
+
+@Suppress("ktlint:standard:argument-list-wrapping")
+public open class TestBase {
+
+    companion object {
+        internal const val OUTPUTS = "DATAFRAME_SAVE_OUTPUTS"
+    }
+
+    @Before
+    fun start() {
+        if (System.getenv(OUTPUTS) != null) {
+            PluginCallbackProxy.start()
+        }
+    }
+
+    @After
+    fun save() {
+        if (System.getenv(OUTPUTS) != null) {
+            PluginCallbackProxy.save()
+        }
+    }
+
+    val df = dataFrameOf("firstName", "lastName", "age", "city", "weight", "isHappy")(
+        "Alice", "Cooper", 15, "London", 54, true,
+        "Bob", "Dylan", 45, "Dubai", 87, true,
+        "Charlie", "Daniels", 20, "Moscow", null, false,
+        "Charlie", "Chaplin", 40, "Milan", null, true,
+        "Bob", "Marley", 30, "Tokyo", 68, true,
+        "Alice", "Wolf", 20, null, 55, false,
+        "Charlie", "Byrd", 30, "Moscow", 90, true,
+    ).group("firstName", "lastName").into("name").cast<Person>()
+
+    val dfGroup = df.convert { name.firstName }.to {
+        val firstName by it
+        val secondName by it.map<_, String?> { null }.asValueColumn()
+        val thirdName by it.map<_, String?> { null }.asValueColumn()
+
+        dataFrameOf(firstName, secondName, thirdName)
+            .cast<FirstNames>(verify = true)
+            .asColumnGroup("firstName")
+    }.cast<Person2>(verify = true)
+
+    @DataSchema
+    interface Name {
+        val firstName: String
+        val lastName: String
+    }
+
+    @DataSchema
+    interface Person {
+        val age: Int
+        val city: String?
+        val name: DataRow<Name>
+        val weight: Int?
+        val isHappy: Boolean
+    }
+
+    interface NonDataSchemaPerson {
+        val age: Int
+        val city: String?
+        val name: Name
+        val weight: Int?
+        val isHappy: Boolean
+    }
+
+    @DataSchema
+    interface FirstNames {
+        val firstName: String
+        val secondName: String?
+        val thirdName: String?
+    }
+
+    @DataSchema
+    interface Name2 {
+        val firstName: DataRow<FirstNames>
+        val lastName: String
+    }
+
+    @DataSchema
+    interface Person2 {
+        val age: Int
+        val city: String?
+        val name: DataRow<Name2>
+        val weight: Int?
+        val isHappy: Boolean
+    }
+
+    infix fun <T, U : T> T.willBe(expected: U?) = shouldBe(expected)
+
+    /**
+     * Asserts that all elements of the iterable are equal to each other
+     */
+    fun <T> Iterable<T>.shouldAllBeEqual(): Iterable<T> {
+        this should {
+            it.reduce { a, b ->
+                a shouldBe b
+                b
+            }
+        }
+        return this
+    }
+
+    /**
+     * Helper function to print List<ColumnWithPath<*>> in a readable way
+     */
+    fun List<ColumnWithPath<*>>.print() {
+        forEach {
+            if (it.isValueColumn()) {
+                println("${it.name}: ${it.type()}")
+            } else {
+                it.print()
+            }
+        }
+        println()
+    }
+
+    /**
+     * Overload for shouldBe for List<ColumnWithPath<*>> to compare only names and paths
+     * since the instances of ColumnWithPath are different
+     */
+    infix fun List<ColumnWithPath<*>>.shouldBe(other: List<ColumnWithPath<*>>) {
+        this.map { it.name to it.path } shouldBe other.map { it.name to it.path }
+    }
+
+    /**
+     * Overload for shouldNotBe for List<ColumnWithPath<*>> to compare only names and paths
+     * since the instances of ColumnWithPath are different
+     */
+    infix fun List<ColumnWithPath<*>>.shouldNotBe(other: List<ColumnWithPath<*>>) {
+        this.map { it.name to it.path } shouldNotBe other.map { it.name to it.path }
+    }
+}
diff --git a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/statistics/BasicMathTests.kt b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/statistics/BasicMathTests.kt
new file mode 100644
index 000000000..0c0c156f2
--- /dev/null
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/statistics/BasicMathTests.kt
@@ -0,0 +1,27 @@
+package org.jetbrains.kotlinx.dataframe.statistics
+
+import io.kotest.matchers.shouldBe
+import org.jetbrains.kotlinx.dataframe.DataColumn
+import org.jetbrains.kotlinx.dataframe.api.columnOf
+import org.jetbrains.kotlinx.dataframe.api.mean
+import org.jetbrains.kotlinx.dataframe.impl.nothingType
+import org.junit.Test
+import kotlin.reflect.typeOf
+
+class BasicMathTests {
+
+    @Test
+    fun `type for column with mixed numbers`() {
+        val col = columnOf(10, 10.0, null)
+        col.type() shouldBe typeOf<Number?>()
+    }
+
+    @Test
+    fun `mean with nans and nulls`() {
+        columnOf(10, 20, Double.NaN, null).mean() shouldBe Double.NaN
+        columnOf(10, 20, Double.NaN, null).mean(skipNA = true) shouldBe 15
+
+        DataColumn.createValueColumn("", emptyList<Nothing>(), nothingType(false)).mean() shouldBe Double.NaN
+        DataColumn.createValueColumn("", listOf(null), nothingType(true)).mean() shouldBe Double.NaN
+    }
+}
diff --git a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/statistics/cumsum.kt b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/statistics/cumsum.kt
new file mode 100644
index 000000000..385023eda
--- /dev/null
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/statistics/cumsum.kt
@@ -0,0 +1,70 @@
+package org.jetbrains.kotlinx.dataframe.statistics
+
+import io.kotest.matchers.shouldBe
+import org.jetbrains.kotlinx.dataframe.DataColumn
+import org.jetbrains.kotlinx.dataframe.api.columnOf
+import org.jetbrains.kotlinx.dataframe.api.concat
+import org.jetbrains.kotlinx.dataframe.api.cumSum
+import org.jetbrains.kotlinx.dataframe.api.dataFrameOf
+import org.jetbrains.kotlinx.dataframe.api.groupBy
+import org.junit.Test
+
+@Suppress("ktlint:standard:argument-list-wrapping")
+class CumsumTests {
+
+    val col by columnOf(1, 2, null, 3, 4)
+    val expected = listOf(1, 3, null, 6, 10)
+    val expectedNoSkip = listOf(1, 3, null, null, null)
+
+    @Test
+    fun `int column`() {
+        col.cumSum().toList() shouldBe expected
+        col.cumSum(skipNA = false).toList() shouldBe expectedNoSkip
+    }
+
+    @Test
+    fun frame() {
+        val str by columnOf("a", "b", "c", "d", "e")
+        val df = dataFrameOf(col, str)
+
+        df.cumSum()[col].toList() shouldBe expected
+        df.cumSum(skipNA = false)[col].toList() shouldBe expectedNoSkip
+
+        df.cumSum { col }[col].toList() shouldBe expected
+        df.cumSum(skipNA = false) { col }[col].toList() shouldBe expectedNoSkip
+
+        df.cumSum(col)[col].toList() shouldBe expected
+        df.cumSum(col, skipNA = false)[col].toList() shouldBe expectedNoSkip
+    }
+
+    @Test
+    fun `double column`() {
+        val doubles by columnOf(1.0, 2.0, null, Double.NaN, 4.0)
+        doubles.cumSum().toList() shouldBe listOf(1.0, 3.0, Double.NaN, Double.NaN, 7.0)
+    }
+
+    @Test
+    fun `number column`() {
+        val doubles: DataColumn<Number?> by columnOf(1, 2, null, Double.NaN, 4)
+        doubles.cumSum().toList() shouldBe listOf(1.0, 3.0, Double.NaN, Double.NaN, 7.0)
+    }
+
+    @Test
+    fun `groupBy`() {
+        val df = dataFrameOf("str", "col")(
+            "a", 1,
+            "b", 2,
+            "c", null,
+            "a", 3,
+            "c", 4,
+        )
+        df.groupBy("str").cumSum().concat() shouldBe
+            dataFrameOf("str", "col")(
+                "a", 1,
+                "a", 4,
+                "b", 2,
+                "c", null,
+                "c", 4,
+            )
+    }
+}
diff --git a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/statistics/median.kt b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/statistics/median.kt
new file mode 100644
index 000000000..bc793b270
--- /dev/null
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/statistics/median.kt
@@ -0,0 +1,34 @@
+package org.jetbrains.kotlinx.dataframe.statistics
+
+import io.kotest.matchers.shouldBe
+import org.jetbrains.kotlinx.dataframe.api.Infer
+import org.jetbrains.kotlinx.dataframe.api.columnOf
+import org.jetbrains.kotlinx.dataframe.api.dataFrameOf
+import org.jetbrains.kotlinx.dataframe.api.mapToColumn
+import org.jetbrains.kotlinx.dataframe.api.median
+import org.jetbrains.kotlinx.dataframe.api.rowMedian
+import org.junit.Test
+
+@Suppress("ktlint:standard:argument-list-wrapping")
+class MedianTests {
+
+    @Test
+    fun `median of two columns`() {
+        val df = dataFrameOf("a", "b")(
+            1, 4,
+            2, 6,
+            7, 7,
+        )
+        df.median("a", "b") shouldBe 5
+    }
+
+    @Test
+    fun `row median`() {
+        val df = dataFrameOf("a", "b")(
+            1, 3,
+            2, 4,
+            7, 7,
+        )
+        df.mapToColumn("", Infer.Type) { it.rowMedian() } shouldBe columnOf(2, 3, 7)
+    }
+}
diff --git a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/statistics/quickSelect.kt b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/statistics/quickSelect.kt
new file mode 100644
index 000000000..5136277b4
--- /dev/null
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/statistics/quickSelect.kt
@@ -0,0 +1,34 @@
+package org.jetbrains.kotlinx.dataframe.statistics
+
+import io.kotest.assertions.throwables.shouldThrow
+import io.kotest.matchers.shouldBe
+import org.jetbrains.kotlinx.dataframe.math.quickSelect
+import org.junit.Test
+import kotlin.random.Random
+
+class QuickSelectTests {
+
+    @Test
+    fun empty() {
+        shouldThrow<IndexOutOfBoundsException> {
+            listOf<Int>().quickSelect(0)
+        }
+    }
+
+    @Test
+    fun short() {
+        val list = listOf(2, 5, 1)
+        list.quickSelect(0) shouldBe 1
+        list.quickSelect(1) shouldBe 2
+        list.quickSelect(2) shouldBe 5
+    }
+
+    @Test
+    fun long() {
+        val random = Random(120)
+        val list = (0..20).shuffled(random)
+        for (i in list) {
+            list.quickSelect(i) shouldBe i
+        }
+    }
+}
diff --git a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/statistics/std.kt b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/statistics/std.kt
new file mode 100644
index 000000000..4d403a173
--- /dev/null
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/statistics/std.kt
@@ -0,0 +1,55 @@
+package org.jetbrains.kotlinx.dataframe.statistics
+
+import io.kotest.matchers.shouldBe
+import org.jetbrains.kotlinx.dataframe.DataColumn
+import org.jetbrains.kotlinx.dataframe.api.columnOf
+import org.jetbrains.kotlinx.dataframe.api.columnTypes
+import org.jetbrains.kotlinx.dataframe.api.dataFrameOf
+import org.jetbrains.kotlinx.dataframe.api.std
+import org.jetbrains.kotlinx.dataframe.impl.nothingType
+import org.jetbrains.kotlinx.dataframe.math.std
+import org.jetbrains.kotlinx.dataframe.type
+import org.junit.Test
+import kotlin.reflect.typeOf
+
+class StdTests {
+
+    @Test
+    fun `std one column`() {
+        val value by columnOf(1, 2, 3)
+        val df = dataFrameOf(value)
+        val expected = 1.0
+
+        value.values().std() shouldBe expected
+        value.values().std(typeOf<Int>()) shouldBe expected
+        value.std() shouldBe expected
+        df[value].std() shouldBe expected
+        df.std { value } shouldBe expected
+        df.std().columnTypes().single() shouldBe typeOf<Double>()
+    }
+
+    @Test
+    fun `std one double column`() {
+        val value by columnOf(1.0, 2.0, 3.0)
+        val df = dataFrameOf(value)
+        val expected = 1.0
+
+        value.values().std() shouldBe expected
+        value.values().std(typeOf<Double>()) shouldBe expected
+        value.std() shouldBe expected
+        df[value].std() shouldBe expected
+        df.std { value } shouldBe expected
+    }
+
+    @Test
+    fun `std on empty or nullable column`() {
+        val empty = DataColumn.createValueColumn("", emptyList<Nothing>(), nothingType(false))
+        val nullable = DataColumn.createValueColumn("", listOf(null), nothingType(true))
+
+        empty.values().std(empty.type) shouldBe Double.NaN
+        nullable.values().std(nullable.type) shouldBe Double.NaN
+
+        empty.std() shouldBe Double.NaN
+        nullable.std() shouldBe Double.NaN
+    }
+}
diff --git a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/testSets/DsSalaries.kt b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/testSets/DsSalaries.kt
new file mode 100644
index 000000000..564369ecf
--- /dev/null
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/testSets/DsSalaries.kt
@@ -0,0 +1,41 @@
+package org.jetbrains.kotlinx.dataframe.testSets
+
+import org.jetbrains.kotlinx.dataframe.annotations.ColumnName
+import org.jetbrains.kotlinx.dataframe.annotations.DataSchema
+
+// Dataset from https://www.kaggle.com/datasets/ruchi798/data-science-job-salaries
+@Suppress("unused")
+@DataSchema
+interface DsSalaries {
+    @ColumnName("company_location")
+    val companyLocation: String
+
+    @ColumnName("company_size")
+    val companySize: String
+
+    @ColumnName("employee_residence")
+    val employeeResidence: String
+
+    @ColumnName("employment_type")
+    val employmentType: String
+
+    @ColumnName("experience_level")
+    val experienceLevel: String
+
+    @ColumnName("job_title")
+    val jobTitle: String
+
+    @ColumnName("remote_ratio")
+    val remoteRatio: Int
+    val salary: Int
+
+    @ColumnName("salary_currency")
+    val salaryCurrency: String
+
+    @ColumnName("salary_in_usd")
+    val salaryInUsd: Int
+    val untitled: Int
+
+    @ColumnName("work_year")
+    val workYear: Int
+}
diff --git a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/testSets/animals/AnimalsTests.kt b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/testSets/animals/AnimalsTests.kt
new file mode 100644
index 000000000..f8ee4b37d
--- /dev/null
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/testSets/animals/AnimalsTests.kt
@@ -0,0 +1,48 @@
+package org.jetbrains.kotlinx.dataframe.testSets.animals
+
+import io.kotest.matchers.shouldBe
+import org.jetbrains.kotlinx.dataframe.api.columnOf
+import org.jetbrains.kotlinx.dataframe.api.dataFrameOf
+import org.jetbrains.kotlinx.dataframe.api.mean
+import org.jetbrains.kotlinx.dataframe.api.name
+import org.jetbrains.kotlinx.dataframe.api.transpose
+import org.jetbrains.kotlinx.dataframe.api.update
+import org.jetbrains.kotlinx.dataframe.api.value
+import org.jetbrains.kotlinx.dataframe.api.with
+import org.jetbrains.kotlinx.dataframe.api.withNull
+import org.junit.Test
+import kotlin.reflect.typeOf
+
+class AnimalsTests {
+
+    val animal by columnOf("cat", "cat", "snake", "dog", "dog", "cat", "snake", "cat", "dog", "dog")
+    val age by columnOf(2.5, 3.0, 0.5, Double.NaN, 5.0, 2.0, 4.5, Double.NaN, 7.0, 3.0)
+    val visits by columnOf(1, 3, 2, 3, 2, 3, 1, 1, 2, 1)
+    val priority by columnOf("yes", "yes", "no", "yes", "no", "no", "no", "yes", "no", "no")
+
+    val df = dataFrameOf(animal, age, visits, priority)
+
+    @Test
+    fun `ignore nans`() {
+        df.mean("age", skipNA = true) shouldBe 3.4375
+    }
+
+    @Test
+    fun `mean transpose`() {
+        val mean = df.mean().transpose()
+        mean.columnsCount() shouldBe 2
+        mean.rowsCount() shouldBe 2
+        mean.name.values() shouldBe listOf("age", "visits")
+        mean.value.type() shouldBe typeOf<Double>()
+    }
+
+    @Test
+    fun `mean of empty`() {
+        val cleared = df
+            .update { age }.with { Double.NaN }
+            .update { visits }.withNull()
+        val mean = cleared.mean()
+        mean[age] shouldBe Double.NaN
+        (mean[visits.name()] as Double).isNaN() shouldBe true
+    }
+}
diff --git a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/testSets/person/BaseJoinTest.kt b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/testSets/person/BaseJoinTest.kt
new file mode 100644
index 000000000..2e3272505
--- /dev/null
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/testSets/person/BaseJoinTest.kt
@@ -0,0 +1,27 @@
+package org.jetbrains.kotlinx.dataframe.testSets.person
+
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.annotations.DataSchema
+import org.jetbrains.kotlinx.dataframe.api.cast
+import org.jetbrains.kotlinx.dataframe.api.dataFrameOf
+
+open class BaseJoinTest : BaseTest() {
+    @Suppress("ktlint:standard:argument-list-wrapping")
+    val df2 = dataFrameOf("name", "origin", "grade", "age")(
+        "Alice", "London", 3, "young",
+        "Alice", "London", 5, "old",
+        "Bob", "Tokyo", 4, "young",
+        "Bob", "Paris", 5, "old",
+        "Charlie", "Moscow", 1, "young",
+        "Charlie", "Moscow", 2, "old",
+        "Bob", "Paris", 4, null,
+    )
+    val typed2: DataFrame<Person2> = df2.cast()
+
+    @DataSchema
+    interface Person2 {
+        val name: String
+        val origin: String?
+        val grade: Int
+    }
+}
diff --git a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/testSets/person/BaseTest.kt b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/testSets/person/BaseTest.kt
new file mode 100644
index 000000000..f67996cce
--- /dev/null
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/testSets/person/BaseTest.kt
@@ -0,0 +1,40 @@
+package org.jetbrains.kotlinx.dataframe.testSets.person
+
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.annotations.DataSchema
+import org.jetbrains.kotlinx.dataframe.api.cast
+import org.jetbrains.kotlinx.dataframe.api.column
+import org.jetbrains.kotlinx.dataframe.api.dataFrameOf
+import org.jetbrains.kotlinx.dataframe.api.toColumnAccessor
+
+@DataSchema
+interface Person {
+    val name: String
+    val age: Int
+    val city: String?
+    val weight: Int?
+}
+
+open class BaseTest {
+
+    // Data set
+    @Suppress("ktlint:standard:argument-list-wrapping")
+    val df = dataFrameOf("name", "age", "city", "weight")(
+        "Alice", 15, "London", 54,
+        "Bob", 45, "Dubai", 87,
+        "Charlie", 20, "Moscow", null,
+        "Charlie", 40, "Milan", null,
+        "Bob", 30, "Tokyo", 68,
+        "Alice", 20, null, 55,
+        "Charlie", 30, "Moscow", 90,
+    )
+
+    val typed: DataFrame<Person> = df.cast()
+
+// Manual Column Definitions
+
+    val name by column<String>()
+    val age = column<Int>() named "age"
+    val city = Person::city.toColumnAccessor()
+    val weight by column<Int?>()
+}
diff --git a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/testSets/person/BuildTests.kt b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/testSets/person/BuildTests.kt
new file mode 100644
index 000000000..42fe23861
--- /dev/null
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/testSets/person/BuildTests.kt
@@ -0,0 +1,33 @@
+package org.jetbrains.kotlinx.dataframe.testSets.person
+
+import io.kotest.matchers.shouldBe
+import org.jetbrains.kotlinx.dataframe.api.toColumn
+import org.jetbrains.kotlinx.dataframe.api.toDataFrame
+import org.jetbrains.kotlinx.dataframe.nrow
+import org.junit.Test
+
+class BuildTests {
+
+    data class Person(val name: String, val age: Int)
+
+    val persons = listOf(Person("Alice", 15), Person("Bob", 20))
+
+    @Test
+    fun test3() {
+        val list = persons + listOf(null)
+        val df = list.toDataFrame()
+        df.nrow shouldBe 3
+    }
+
+    @Test(expected = IllegalArgumentException::class)
+    fun `unequal column sizes`() {
+        persons.toDataFrame() + listOf(1, 2, 3).toColumn("id")
+    }
+
+    @Test
+    fun `create dataframe`() {
+        persons.toDataFrame {
+            expr { it.age + 4 } into "age"
+        }
+    }
+}
diff --git a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/testSets/person/DataColumnTests.kt b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/testSets/person/DataColumnTests.kt
new file mode 100644
index 000000000..9e97978e5
--- /dev/null
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/testSets/person/DataColumnTests.kt
@@ -0,0 +1,28 @@
+package org.jetbrains.kotlinx.dataframe.testSets.person
+
+import io.kotest.matchers.shouldBe
+import org.jetbrains.kotlinx.dataframe.api.columnOf
+import org.jetbrains.kotlinx.dataframe.api.count
+import org.jetbrains.kotlinx.dataframe.api.sort
+import org.jetbrains.kotlinx.dataframe.api.sortBy
+import org.jetbrains.kotlinx.dataframe.api.sortByDesc
+import org.jetbrains.kotlinx.dataframe.api.sortDesc
+import org.jetbrains.kotlinx.dataframe.api.valueCounts
+import org.junit.Test
+
+class DataColumnTests : BaseTest() {
+
+    @Test
+    fun `sort column`() {
+        typed.age.sort() shouldBe typed.sortBy { age }.age
+        typed.age.sortDesc() shouldBe typed.sortByDesc { age }.age
+    }
+
+    @Test
+    fun `value counts`() {
+        val languages by columnOf("Kotlin", "Kotlin", null, null, "C++")
+        val languageCounts = languages.valueCounts()
+        languageCounts[languages].values() shouldBe listOf("Kotlin", "C++")
+        languageCounts.count.values() shouldBe listOf(2, 1)
+    }
+}
diff --git a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/testSets/person/DataFrameTests.kt b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/testSets/person/DataFrameTests.kt
new file mode 100644
index 000000000..63ee6c5e0
--- /dev/null
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/testSets/person/DataFrameTests.kt
@@ -0,0 +1,2726 @@
+package org.jetbrains.kotlinx.dataframe.testSets.person
+
+import io.kotest.assertions.throwables.shouldThrow
+import io.kotest.matchers.doubles.ToleranceMatcher
+import io.kotest.matchers.should
+import io.kotest.matchers.shouldBe
+import io.kotest.matchers.shouldNotBe
+import org.jetbrains.kotlinx.dataframe.AnyFrame
+import org.jetbrains.kotlinx.dataframe.AnyRow
+import org.jetbrains.kotlinx.dataframe.DataColumn
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.DataRow
+import org.jetbrains.kotlinx.dataframe.RowExpression
+import org.jetbrains.kotlinx.dataframe.alsoDebug
+import org.jetbrains.kotlinx.dataframe.annotations.ColumnName
+import org.jetbrains.kotlinx.dataframe.annotations.DataSchema
+import org.jetbrains.kotlinx.dataframe.api.ExcessiveColumns
+import org.jetbrains.kotlinx.dataframe.api.GroupBy
+import org.jetbrains.kotlinx.dataframe.api.Infer
+import org.jetbrains.kotlinx.dataframe.api.ParserOptions
+import org.jetbrains.kotlinx.dataframe.api.add
+import org.jetbrains.kotlinx.dataframe.api.addAll
+import org.jetbrains.kotlinx.dataframe.api.addId
+import org.jetbrains.kotlinx.dataframe.api.aggregate
+import org.jetbrains.kotlinx.dataframe.api.all
+import org.jetbrains.kotlinx.dataframe.api.allNulls
+import org.jetbrains.kotlinx.dataframe.api.append
+import org.jetbrains.kotlinx.dataframe.api.asColumnGroup
+import org.jetbrains.kotlinx.dataframe.api.asDataFrame
+import org.jetbrains.kotlinx.dataframe.api.asGroupBy
+import org.jetbrains.kotlinx.dataframe.api.asIterable
+import org.jetbrains.kotlinx.dataframe.api.at
+import org.jetbrains.kotlinx.dataframe.api.between
+import org.jetbrains.kotlinx.dataframe.api.by
+import org.jetbrains.kotlinx.dataframe.api.cast
+import org.jetbrains.kotlinx.dataframe.api.chunked
+import org.jetbrains.kotlinx.dataframe.api.colsOf
+import org.jetbrains.kotlinx.dataframe.api.column
+import org.jetbrains.kotlinx.dataframe.api.columnGroup
+import org.jetbrains.kotlinx.dataframe.api.columnOf
+import org.jetbrains.kotlinx.dataframe.api.concat
+import org.jetbrains.kotlinx.dataframe.api.convert
+import org.jetbrains.kotlinx.dataframe.api.convertTo
+import org.jetbrains.kotlinx.dataframe.api.corr
+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.default
+import org.jetbrains.kotlinx.dataframe.api.describe
+import org.jetbrains.kotlinx.dataframe.api.digitize
+import org.jetbrains.kotlinx.dataframe.api.distinct
+import org.jetbrains.kotlinx.dataframe.api.distinctBy
+import org.jetbrains.kotlinx.dataframe.api.div
+import org.jetbrains.kotlinx.dataframe.api.drop
+import org.jetbrains.kotlinx.dataframe.api.dropLast
+import org.jetbrains.kotlinx.dataframe.api.dropNA
+import org.jetbrains.kotlinx.dataframe.api.dropNulls
+import org.jetbrains.kotlinx.dataframe.api.dropWhile
+import org.jetbrains.kotlinx.dataframe.api.explode
+import org.jetbrains.kotlinx.dataframe.api.expr
+import org.jetbrains.kotlinx.dataframe.api.fill
+import org.jetbrains.kotlinx.dataframe.api.fillNulls
+import org.jetbrains.kotlinx.dataframe.api.filter
+import org.jetbrains.kotlinx.dataframe.api.first
+import org.jetbrains.kotlinx.dataframe.api.forEach
+import org.jetbrains.kotlinx.dataframe.api.forEachIndexed
+import org.jetbrains.kotlinx.dataframe.api.frameColumn
+import org.jetbrains.kotlinx.dataframe.api.gather
+import org.jetbrains.kotlinx.dataframe.api.getColumn
+import org.jetbrains.kotlinx.dataframe.api.getColumnGroup
+import org.jetbrains.kotlinx.dataframe.api.getColumns
+import org.jetbrains.kotlinx.dataframe.api.getFrameColumn
+import org.jetbrains.kotlinx.dataframe.api.getValue
+import org.jetbrains.kotlinx.dataframe.api.group
+import org.jetbrains.kotlinx.dataframe.api.groupBy
+import org.jetbrains.kotlinx.dataframe.api.implode
+import org.jetbrains.kotlinx.dataframe.api.indices
+import org.jetbrains.kotlinx.dataframe.api.inplace
+import org.jetbrains.kotlinx.dataframe.api.into
+import org.jetbrains.kotlinx.dataframe.api.intoColumns
+import org.jetbrains.kotlinx.dataframe.api.intoList
+import org.jetbrains.kotlinx.dataframe.api.intoRows
+import org.jetbrains.kotlinx.dataframe.api.isColumnGroup
+import org.jetbrains.kotlinx.dataframe.api.isComparable
+import org.jetbrains.kotlinx.dataframe.api.isEmpty
+import org.jetbrains.kotlinx.dataframe.api.isFrameColumn
+import org.jetbrains.kotlinx.dataframe.api.isNA
+import org.jetbrains.kotlinx.dataframe.api.isNumber
+import org.jetbrains.kotlinx.dataframe.api.keysInto
+import org.jetbrains.kotlinx.dataframe.api.last
+import org.jetbrains.kotlinx.dataframe.api.leftJoin
+import org.jetbrains.kotlinx.dataframe.api.lowercase
+import org.jetbrains.kotlinx.dataframe.api.map
+import org.jetbrains.kotlinx.dataframe.api.mapToFrame
+import org.jetbrains.kotlinx.dataframe.api.match
+import org.jetbrains.kotlinx.dataframe.api.matches
+import org.jetbrains.kotlinx.dataframe.api.max
+import org.jetbrains.kotlinx.dataframe.api.maxBy
+import org.jetbrains.kotlinx.dataframe.api.mean
+import org.jetbrains.kotlinx.dataframe.api.meanFor
+import org.jetbrains.kotlinx.dataframe.api.meanOf
+import org.jetbrains.kotlinx.dataframe.api.median
+import org.jetbrains.kotlinx.dataframe.api.merge
+import org.jetbrains.kotlinx.dataframe.api.min
+import org.jetbrains.kotlinx.dataframe.api.minBy
+import org.jetbrains.kotlinx.dataframe.api.minOf
+import org.jetbrains.kotlinx.dataframe.api.minus
+import org.jetbrains.kotlinx.dataframe.api.move
+import org.jetbrains.kotlinx.dataframe.api.moveTo
+import org.jetbrains.kotlinx.dataframe.api.moveToLeft
+import org.jetbrains.kotlinx.dataframe.api.moveToRight
+import org.jetbrains.kotlinx.dataframe.api.name
+import org.jetbrains.kotlinx.dataframe.api.named
+import org.jetbrains.kotlinx.dataframe.api.notNull
+import org.jetbrains.kotlinx.dataframe.api.nullable
+import org.jetbrains.kotlinx.dataframe.api.parse
+import org.jetbrains.kotlinx.dataframe.api.pathOf
+import org.jetbrains.kotlinx.dataframe.api.pivot
+import org.jetbrains.kotlinx.dataframe.api.print
+import org.jetbrains.kotlinx.dataframe.api.remove
+import org.jetbrains.kotlinx.dataframe.api.rename
+import org.jetbrains.kotlinx.dataframe.api.reorderColumnsByName
+import org.jetbrains.kotlinx.dataframe.api.replace
+import org.jetbrains.kotlinx.dataframe.api.rows
+import org.jetbrains.kotlinx.dataframe.api.schema
+import org.jetbrains.kotlinx.dataframe.api.select
+import org.jetbrains.kotlinx.dataframe.api.single
+import org.jetbrains.kotlinx.dataframe.api.sortBy
+import org.jetbrains.kotlinx.dataframe.api.sortByCount
+import org.jetbrains.kotlinx.dataframe.api.sortByDesc
+import org.jetbrains.kotlinx.dataframe.api.sortByKey
+import org.jetbrains.kotlinx.dataframe.api.sortWith
+import org.jetbrains.kotlinx.dataframe.api.split
+import org.jetbrains.kotlinx.dataframe.api.sum
+import org.jetbrains.kotlinx.dataframe.api.sumOf
+import org.jetbrains.kotlinx.dataframe.api.take
+import org.jetbrains.kotlinx.dataframe.api.takeLast
+import org.jetbrains.kotlinx.dataframe.api.takeWhile
+import org.jetbrains.kotlinx.dataframe.api.times
+import org.jetbrains.kotlinx.dataframe.api.to
+import org.jetbrains.kotlinx.dataframe.api.toColumn
+import org.jetbrains.kotlinx.dataframe.api.toColumnAccessor
+import org.jetbrains.kotlinx.dataframe.api.toColumnOf
+import org.jetbrains.kotlinx.dataframe.api.toDataFrame
+import org.jetbrains.kotlinx.dataframe.api.toDouble
+import org.jetbrains.kotlinx.dataframe.api.toInt
+import org.jetbrains.kotlinx.dataframe.api.toList
+import org.jetbrains.kotlinx.dataframe.api.toListOf
+import org.jetbrains.kotlinx.dataframe.api.toMap
+import org.jetbrains.kotlinx.dataframe.api.toRight
+import org.jetbrains.kotlinx.dataframe.api.toStr
+import org.jetbrains.kotlinx.dataframe.api.toValueColumn
+import org.jetbrains.kotlinx.dataframe.api.transpose
+import org.jetbrains.kotlinx.dataframe.api.under
+import org.jetbrains.kotlinx.dataframe.api.ungroup
+import org.jetbrains.kotlinx.dataframe.api.update
+import org.jetbrains.kotlinx.dataframe.api.value
+import org.jetbrains.kotlinx.dataframe.api.values
+import org.jetbrains.kotlinx.dataframe.api.valuesNotNull
+import org.jetbrains.kotlinx.dataframe.api.where
+import org.jetbrains.kotlinx.dataframe.api.with
+import org.jetbrains.kotlinx.dataframe.api.withNull
+import org.jetbrains.kotlinx.dataframe.api.withValues
+import org.jetbrains.kotlinx.dataframe.api.withZero
+import org.jetbrains.kotlinx.dataframe.api.xs
+import org.jetbrains.kotlinx.dataframe.columns.ColumnKind
+import org.jetbrains.kotlinx.dataframe.columns.UnresolvedColumnsPolicy
+import org.jetbrains.kotlinx.dataframe.exceptions.ExcessiveColumnsException
+import org.jetbrains.kotlinx.dataframe.exceptions.TypeConversionException
+import org.jetbrains.kotlinx.dataframe.get
+import org.jetbrains.kotlinx.dataframe.hasNulls
+import org.jetbrains.kotlinx.dataframe.impl.DataFrameImpl
+import org.jetbrains.kotlinx.dataframe.impl.DataFrameSize
+import org.jetbrains.kotlinx.dataframe.impl.api.convertToImpl
+import org.jetbrains.kotlinx.dataframe.impl.between
+import org.jetbrains.kotlinx.dataframe.impl.columns.isMissingColumn
+import org.jetbrains.kotlinx.dataframe.impl.emptyPath
+import org.jetbrains.kotlinx.dataframe.impl.getColumnsImpl
+import org.jetbrains.kotlinx.dataframe.impl.nothingType
+import org.jetbrains.kotlinx.dataframe.impl.trackColumnAccess
+import org.jetbrains.kotlinx.dataframe.index
+import org.jetbrains.kotlinx.dataframe.io.renderValueForStdout
+import org.jetbrains.kotlinx.dataframe.kind
+import org.jetbrains.kotlinx.dataframe.math.mean
+import org.jetbrains.kotlinx.dataframe.name
+import org.jetbrains.kotlinx.dataframe.ncol
+import org.jetbrains.kotlinx.dataframe.nrow
+import org.jetbrains.kotlinx.dataframe.size
+import org.jetbrains.kotlinx.dataframe.type
+import org.jetbrains.kotlinx.dataframe.typeClass
+import org.junit.Test
+import java.lang.reflect.Type
+import java.math.BigDecimal
+import java.time.LocalDate
+import kotlin.reflect.jvm.jvmErasure
+import kotlin.reflect.typeOf
+
+@Suppress("ktlint:standard:argument-list-wrapping")
+class DataFrameTests : BaseTest() {
+
+    @Test
+    fun `create with columns`() {
+        dataFrameOf("name", "age", "city", "weight")(df.columns()) shouldBe df
+
+        dataFrameOf("name", "age", "city", "weight")(
+            typed.name named "bla",
+            typed.age named "",
+            typed.city.rename("qq"),
+            typed.weight.named("asda"),
+        ) shouldBe df
+
+        val c1 = typed.name.toList().toValueColumn()
+        val c2 = typed.age.toList().toValueColumn()
+        val c3 = typed.city.toList().toValueColumn()
+        val c4 = typed.weight.toList().toValueColumn()
+
+        dataFrameOf("name", "age", "city", "weight")(c1, c2, c3, c4) shouldBe df
+    }
+
+    @Test
+    fun `guess column type for type without classifier`() {
+        val df = dataFrameOf("a", "b")({ 1 }, 2)
+        df["a"].type() shouldBe typeOf<Function<*>>()
+        (df["a"][0] as () -> Int).invoke() shouldBe 1
+    }
+
+    @Test
+    fun `create with columnOf`() {
+        val col = columnOf("Alice", "Bob")
+        val d = dataFrameOf("name")(col)
+        d.nrow shouldBe 2
+        d.columnNames() shouldBe listOf("name")
+    }
+
+    @Test
+    fun `create with unnamed columns`() {
+        val a = columnOf("Alice", "Bob")
+        val b = columnOf(1, 2)
+        val d = dataFrameOf(a, b)
+        d.nrow shouldBe 2
+        d.ncol shouldBe 2
+        d.columnNames() shouldBe listOf("untitled", "untitled1")
+        d["untitled"] shouldBe d.getColumn(0)
+    }
+
+    @Test(expected = IllegalArgumentException::class)
+    fun `create with duplicate columns`() {
+        val a = columnOf("Alice", "Bob") named "col"
+        val b = columnOf(1, 2) named "col"
+        val d = dataFrameOf(a, b)
+    }
+
+    @Test
+    fun `create column reference`() {
+        val name by column<String>()
+        val col = name.withValues("Alice", "Bob")
+        val df = col.toDataFrame()
+        df.nrow shouldBe 2
+        df.columnNames() shouldBe listOf("name")
+    }
+
+    @Test
+    fun `add values to column reference`() {
+        val name by column<String>()
+        val values = listOf("Alice", "Bob")
+        val col1 = name.withValues(values)
+        val col2 = values.toColumn(name)
+        col1 shouldBe col2
+    }
+
+    @Test
+    fun `create from map`() {
+        val data = mapOf("name" to listOf("Alice", "Bob"), "age" to listOf(15, null))
+        val df = data.toDataFrame()
+        df.ncol shouldBe 2
+        df.nrow shouldBe 2
+        df.columnNames() shouldBe listOf("name", "age")
+        df["name"].type() shouldBe typeOf<String>()
+        df["age"].type() shouldBe typeOf<Int?>()
+    }
+
+    @Test
+    fun `toMap`() {
+        val map = df.toMap()
+        map.size shouldBe 4
+        map.forEach {
+            it.value.size shouldBe df.nrow
+        }
+    }
+
+    @Test
+    fun `size`() {
+        df.size() shouldBe DataFrameSize(df.ncol, df.nrow)
+    }
+
+    @Test
+    fun `slicing`() {
+        val sliced = typed[1..2]
+        sliced.nrow shouldBe 2
+        sliced[0].name shouldBe typed[1].name
+    }
+
+    @Test
+    fun `access tracking`() {
+        trackColumnAccess {
+            typed[2].age
+        } shouldBe listOf("age")
+    }
+
+    @Test
+    fun `indexing`() {
+        val expected = 45
+        val i = 1
+
+        fun Int.check() = this shouldBe expected
+
+        typed[i].age.check()
+        typed.age[i].check()
+
+        df[i][age].check()
+        df[age][i].check()
+
+        df[i][Person::age].check()
+        df[Person::age][i].check()
+
+        df[i].getValue<Int>("age").check()
+        (df[i]["age"] as Int).check()
+
+        df["age"].cast<Int>()[i].check()
+        (df["age"][i] as Int).check()
+    }
+
+    @Test
+    fun `null indexing`() {
+        val i = 5
+
+        fun String?.check() = this shouldBe null
+
+        typed[i].city.check()
+        typed.city[i].check()
+
+        df[i][city].check()
+        df[city][i].check()
+
+        df[i][Person::city].check()
+        df[Person::city][i].check()
+
+        df[i].getValue<String?>("city").check()
+        (df[i]["city"] as String?).check()
+
+        df["city"].cast<String?>()[i].check()
+        (df["city"][i] as String?).check()
+    }
+
+    @Test
+    fun `incorrect column nullability`() {
+        // non-nullable column definition is incorrect here, because actual dataframe has nulls in this column
+        val col = column<Int>().named("weight")
+
+        shouldThrow<NullPointerException> {
+            println(df[2][col])
+        }
+    }
+
+    @Test
+    fun `chunked`() {
+        val res = df.chunked(2)
+        res.size() shouldBe 4
+        res.toList().dropLast(1).forEach {
+            it.nrow shouldBe 2
+        }
+    }
+
+    @Test
+    fun `update`() {
+        fun AnyFrame.check() {
+            getColumn(1).name() shouldBe "age"
+            ncol shouldBe typed.ncol
+            this["age"].toList() shouldBe typed.rows().map { it.age * 2 }
+        }
+
+        typed.update { age }.with { it * 2 }.check()
+        typed.update { age }.with { it * 2 }.check()
+        typed.update(typed.age) { it * 2 }.check()
+
+        df.update { age }.with { it * 2 }.check()
+        df.update(age) { it * 2 }.check()
+        df.update(age) { it * 2 }.check()
+
+        df.update(Person::age) { it * 2 }.check()
+
+        df.update("age") { "age"<Int>() * 2 }.check()
+    }
+
+    @Test
+    fun `conditional update`() {
+        fun AnyFrame.check() {
+            getColumn(1).name() shouldBe "age"
+            ncol shouldBe typed.ncol
+            this["age"].toList() shouldBe typed.rows().map { if (it.age > 25) null else it.age }
+        }
+
+        typed.update { age }.where { it > 25 }.withNull().check()
+        typed.update { age }.where { it > 25 }.withNull().check()
+        typed.update(typed.age).where { it > 25 }.withNull().check()
+
+        df.update { age }.where { it > 25 }.withNull().check()
+        df.update(age).where { it > 25 }.withNull().check()
+        df.update(age).where { it > 25 }.withNull().check()
+
+        df.update(Person::age).where { it > 25 }.withNull().check()
+
+        df.update("age").where { it as Int > 25 }.withNull().check()
+        df.update("age").where { it as Int > 25 }.withNull().check()
+    }
+
+    @Test
+    fun `update cells by index`() {
+        val res = typed.update { age }.at(2, 4).with { 100 }
+        val expected = typed.rows().map { if (it.index == 2 || it.index == 4) 100 else it.age }
+        res.age.toList() shouldBe expected
+    }
+
+    @Test
+    fun `update cells by index range`() {
+        val res = typed.update { age }.at(2..4).with { 100 }
+        val expected = typed.rows().map { if (it.index in 2..4) 100 else it.age }
+        res.age.toList() shouldBe expected
+    }
+
+    @Test
+    fun `null to zero`() {
+        val expected = typed.weight.toList().map { it ?: 0 }
+
+        fun AnyFrame.check() {
+            this["weight"].toList() shouldBe expected
+        }
+
+        typed.fillNulls { weight }.with { 0 }.check()
+        typed.fillNulls(typed.weight).with { 0 }.check()
+
+        df.fillNulls { weight }.with { 0 }.check()
+        df.fillNulls(weight).with { 0 }.check()
+
+        df.fillNulls("weight").with { 0 }.check()
+
+        typed.fillNulls { weight }.withZero().check()
+        typed.fillNulls { weight }.withZero().check()
+        typed.fillNulls(typed.weight).withZero().check()
+
+        df.fillNulls { weight }.withZero().check()
+        df.fillNulls { weight }.withZero().check()
+    }
+
+    @Test
+    fun `resetToNull`() {
+        val updated = typed.update { all() }.withNull()
+
+        updated.columns().forEach {
+            it.forEach { it shouldBe null }
+        }
+    }
+
+    @Test
+    fun `sort`() {
+        val expected = listOf(null, "London", "Dubai", "Tokyo", "Milan", "Moscow", "Moscow")
+
+        fun AnyFrame.check() = this[city].toList() shouldBe expected
+
+        typed.sortBy { name and age.desc() }.check()
+        typed.sortBy { it.name and it.age.desc() }.check()
+
+        df.sortBy { name and age.desc() }.check()
+
+        df.sortBy { Person::name and Person::age.desc() }.check()
+
+        df.sortBy { "name"<String>() and "age".desc() }.check()
+    }
+
+    @Test
+    fun `sort nulls first`() {
+        val expected = typed.city.toList().sortedBy { it }
+
+        fun AnyFrame.check() = this[city].toList() shouldBe expected
+
+        typed.sortBy { city }.check()
+        df.sortBy { city }.check()
+        df.sortBy { col(Person::city) }.check()
+        df.sortBy { get("city") }.check()
+    }
+
+    @Test
+    fun `sort nulls last`() {
+        val expected = typed.city.toList().filterNotNull().sortedBy { it } + listOf(null)
+
+        fun AnyFrame.check() = this[city].toList() shouldBe expected
+
+        typed.sortBy { city.nullsLast() }.check()
+        df.sortBy { city.nullsLast() }.check()
+        df.sortBy { Person::city.nullsLast() }.check()
+        df.sortBy { "city".nullsLast() }.check()
+    }
+
+    @Test
+    fun `equals`() {
+        typed shouldBe typed.update { age }.with { age }
+    }
+
+    @Test
+    fun `get group by single key`() {
+        typed.groupBy { name }.xs("Charlie").concat() shouldBe typed.filter { name == "Charlie" }.remove { name }
+    }
+
+    @Test
+    fun `get group by complex key`() {
+        typed.groupBy { city and name }.xs("Tokyo", "Bob").concat() shouldBe
+            typed.filter { name == "Bob" && city == "Tokyo" }
+                .remove { name and city }
+    }
+
+    @Test
+    fun `get group by partial key`() {
+        typed.groupBy { city and name }.xs("Tokyo").toDataFrame() shouldBe
+            typed.filter { city == "Tokyo" }
+                .remove { city }
+                .groupBy { name }.toDataFrame()
+    }
+
+    @Test
+    fun `group and sort`() {
+        val expected = typed.sortBy { name.desc() and age }
+        val actual = typed.groupBy { name }.sortBy { name.desc() and age }.concat()
+        actual shouldBe expected
+    }
+
+    @Test
+    fun `filter`() {
+        val expected = listOf("Bob", "Bob", "Charlie")
+
+        fun AnyFrame.check() = this[name].toList() shouldBe expected
+
+        val limit = 20
+
+        typed.filter { it.age > limit && it.weight != null }.check()
+        typed.filter { age > limit && it.weight != null }.check()
+
+        df.filter { it[Person::age] > limit && it[Person::weight] != null }.check()
+
+        df.filter { age > limit && weight() != null }.check()
+        df.filter { it[age] > limit && this[weight] != null }.check()
+
+        df.filter { "age"<Int>() > limit && "weight"<Int?>() != null }.check()
+    }
+
+    @Test
+    fun `drop nulls 1`() {
+        fun AnyFrame.check() = rows().forEach { get("weight") shouldNotBe null }
+
+        typed.dropNulls(typed.weight).check()
+        typed.dropNulls { weight }.check()
+        typed.dropNulls { it.weight }.check()
+
+        df.dropNulls(weight).check()
+        df.dropNulls { weight }.check()
+
+        df.dropNulls("weight").check()
+    }
+
+    @Test
+    fun `drop where all null`() {
+        val filtered = typed.update { weight }.where { name == "Alice" }.withNull()
+        val expected = typed.nrow - 1
+
+        fun AnyFrame.check() = nrow shouldBe expected
+
+        filtered.dropNulls(typed.weight.toColumnAccessor(), typed.city.toColumnAccessor(), whereAllNull = true).check()
+        filtered.dropNulls(whereAllNull = true) { weight and city }.check()
+        filtered.dropNulls(whereAllNull = true) { it.weight and it.city }.check()
+
+        filtered.dropNulls(Person::weight, Person::city, whereAllNull = true).check()
+
+        filtered.dropNulls(weight, city, whereAllNull = true).check()
+        filtered.dropNulls(whereAllNull = true) { weight and city }.check()
+
+        filtered.dropNulls("weight", "city", whereAllNull = true).check()
+    }
+
+    @Test
+    fun `drop where any null`() {
+        val filtered = typed.update { weight }.where { name == "Alice" }.withNull()
+        val expected = filtered.count { weight != null && city != null }
+
+        fun AnyFrame.check() = nrow shouldBe expected
+
+        filtered.dropNulls(typed.weight.toColumnAccessor(), typed.city.toColumnAccessor()).check()
+        filtered.dropNulls { weight and city }.check()
+        filtered.dropNulls { it.weight and it.city }.check()
+
+        filtered.dropNulls(Person::weight, Person::city).check()
+
+        filtered.dropNulls(weight, city).check()
+        filtered.dropNulls { weight and city }.check()
+
+        filtered.dropNulls("weight", "city").check()
+
+        filtered.dropNulls().check()
+
+        filtered.select { weight and city }.dropNulls().check()
+    }
+
+    @Test
+    fun `select one `() {
+        val expected = listOf(typed.age)
+
+        fun AnyFrame.check() = columns() shouldBe expected
+
+        typed.select { age }.check()
+        typed.select { it.age }.check()
+        typed.select(typed.age).check()
+
+        df.select(Person::age).check()
+
+        df.select { age }.check()
+        df.select(age).check()
+
+        df.select("age").check()
+
+        df.select { it["age"] }.check()
+        df.select { get("age") }.check()
+        df.select { this["age"] }.check()
+    }
+
+    @Test
+    fun `select if`() {
+        val expected = listOf(typed.name, typed.city)
+
+        fun AnyFrame.check() = columns() shouldBe expected
+
+        typed.select { cols { it.name().length == 4 } }.check()
+        df.select { cols { it.name().length == 4 } }.check()
+    }
+
+    @Test
+    fun `select two`() {
+        val expected = listOf(typed.age, typed.city)
+
+        fun AnyFrame.check() = columns() shouldBe expected
+
+        typed.select { age and city }.check()
+        typed.select { it.age and it.city }.check()
+        typed.select(typed.age, typed.city).check()
+
+        typed.select(Person::age, Person::city).check()
+
+        df.select { age and city }.check()
+        df.select(age, city).check()
+        df[age, city].check()
+
+        df.select { "age" and "city" }.check()
+        df.select("age", "city").check()
+        df["age", "city"].check()
+    }
+
+    @Test
+    fun `select by type`() {
+        val selected = typed.select { colsOf<String?>() }
+        selected shouldBe typed.select { name and city }
+    }
+
+    @Test
+    fun `select by type not nullable`() {
+        val selected = typed.select { colsOf<String> { !it.hasNulls() } }
+        selected shouldBe typed.select { name }
+    }
+
+    @Test
+    fun `move one column`() {
+        val moved = typed.moveTo(1) { city }
+        val expected = typed.select { cols(name, city, age, weight) }
+        moved shouldBe expected
+    }
+
+    @Test
+    fun `move several columns`() {
+        val moved = typed.moveTo(2) { name and city }
+        val expected = typed.select { cols(age, weight, name, city) }
+        moved shouldBe expected
+    }
+
+    @Test
+    fun `move several columns to left`() {
+        val moved = typed.moveToLeft { weight and age }
+        val expected = typed.select { cols(weight, age, name, city) }
+        moved shouldBe expected
+    }
+
+    @Test
+    fun `move several columns to right`() {
+        val moved = typed.moveToRight { weight and name }
+        val expected = typed.select { cols(age, city, weight, name) }
+        moved shouldBe expected
+    }
+
+    @Test
+    fun `select with rename 2`() {
+        val res = typed.select { name named "Name" }
+        res.columnNames() shouldBe listOf("Name")
+        df.select { name named "Name" } shouldBe res
+        df.select { it["name"] named "Name" } shouldBe res
+    }
+
+    @Test
+    fun `select with map and rename`() {
+        val res = typed.select { name.map { it.lowercase() } named "Name" }
+        res.columnNames() shouldBe listOf("Name")
+        res["Name"].values() shouldBe typed.name.values().map { it.lowercase() }
+        df.select { name.map { it.lowercase() } named "Name" } shouldBe res
+        df.select { it[Person::name].map { it.lowercase() } named "Name" } shouldBe res
+        df.select { "name"<String>().map { it.lowercase() } named "Name" } shouldBe res
+    }
+
+    @Test
+    fun `get column with map`() {
+        val converted = name.map { it.lowercase() }
+        val res = df[converted]
+        res.values() shouldBe typed.name.values().map { it.lowercase() }
+    }
+
+    @Test
+    fun `get column by accessor`() {
+        val res = df[0..1][name]
+        res.size() shouldBe 2
+    }
+
+    @Test
+    fun `groupBy`() {
+        fun AnyFrame.check() {
+            nrow shouldBe 3
+            this["name"].toList() shouldBe listOf("Alice", "Bob", "Charlie")
+            this["n"].toList() shouldBe listOf(2, 2, 3)
+            this["old count"].toList() shouldBe listOf(0, 2, 2)
+            this["median age"].toList() shouldBe listOf(17, 37, 30)
+            this["min age"].toList() shouldBe listOf(15, 30, 20)
+            this["oldest origin"].toList() shouldBe listOf(null, "Dubai", "Milan")
+            this["youngest origin"].toList() shouldBe listOf("London", "Tokyo", "Moscow")
+            this["all with weights"].toList() shouldBe listOf(true, true, false)
+            val cities = getColumnGroup("city")
+            cities["from London"].toList() shouldBe listOf(1, 0, 0)
+            cities["from Dubai"].toList() shouldBe listOf(0, 1, 0)
+            cities["from Moscow"].toList() shouldBe listOf(0, 0, 2)
+            cities["from Milan"].toList() shouldBe listOf(0, 0, 1)
+            cities["from Tokyo"].toList() shouldBe listOf(0, 1, 0)
+            cities["from null"].toList() shouldBe listOf(1, 0, 0)
+            this["ages"].toList() shouldBe listOf(listOf(15, 20), listOf(45, 30), listOf(20, 40, 30))
+        }
+
+        typed.groupBy { name }.aggregate {
+            count() into "n"
+            count { age > 25 } into "old count"
+            median { age } into "median age"
+            min { age } into "min age"
+            all { weight != null } into "all with weights"
+            maxBy { age }.city into "oldest origin"
+            sortBy { age }.first().city into "youngest origin"
+            pivot { city.map { "from $it" } }.count()
+            age.toList() into "ages"
+        }.check()
+
+        typed.groupBy { it.name }.aggregate {
+            it.nrow into "n"
+            it.count { it.age > 25 } into "old count"
+            it.median { it.age } into "median age"
+            it.min { it.age } into "min age"
+            it.all { it.weight != null } into "all with weights"
+            it.maxBy { it.age }.city into "oldest origin"
+            it.sortBy { it.age }.first().city into "youngest origin"
+            it.pivot { it.city.map { "from $it" } }.count()
+            it.age.toList() into "ages"
+        }.check()
+
+        df.groupBy(name).aggregate {
+            count() into "n"
+            count { age > 25 } into "old count"
+            median(age) into "median age"
+            min(age) into "min age"
+            all { weight() != null } into "all with weights"
+            maxBy(age)[city] into "oldest origin"
+            sortBy(age).first()[city] into "youngest origin"
+            pivot(city.map { "from $it" }).count()
+            it[age].toList() into "ages"
+        }.check()
+
+        df.groupBy(Person::name).aggregate {
+            count() into "n"
+            count { it[Person::age] > 25 } into "old count"
+            median(Person::age) into "median age"
+            min(Person::age) into "min age"
+            all { it[Person::weight] != null } into "all with weights"
+            maxBy(Person::age)[Person::city] into "oldest origin"
+            sortBy(Person::age).first()[Person::city] into "youngest origin"
+            pivot { it[Person::city].map { "from $it" } }.count()
+            it[Person::age].toList() into "ages"
+        }.check()
+
+        df.groupBy("name").aggregate {
+            count() into "n"
+            count { "age"<Int>() > 25 } into "old count"
+            median { "age"<Int>() } into "median age"
+            min { "age"<Int>() } into "min age"
+            all { it["weight"] != null } into "all with weights"
+            maxBy { "age"<Int>() }["city"] into "oldest origin"
+            sortBy("age").first()["city"] into "youngest origin"
+            pivot { it["city"].map { "from $it" } }.count()
+            it["age"].toList() into "ages"
+        }.check()
+    }
+
+    @Test
+    fun `groupBy meanOf`() {
+        typed.groupBy { name }.meanOf { age * 2 } shouldBe typed
+            .groupBy { name }.aggregate { mean { age } * 2 into "mean" }
+    }
+
+    @Test
+    fun `min`() {
+        val expected = 15
+
+        fun Any?.check() = this shouldBe expected
+
+        typed.minOf { age }.check()
+        typed.min { it.age }.check()
+        typed.age.min().check()
+
+        df.min { age }.check()
+        df.min(age).check()
+        df[age].min().check()
+
+        df.min { "age"<Int>() }.check()
+        df.min("age").check()
+        df["age"].cast<Int>().min().check()
+    }
+
+    @Test
+    fun `nullable max`() {
+        val expected = 90
+
+        fun Int?.check() = this shouldBe expected
+
+        typed.max { weight }.check()
+        typed.max { it.weight }.check()
+        typed.weight.max().check()
+
+        df.max { weight }.check()
+        df.max(weight).check()
+        df[weight].max().check()
+
+        df.max { "weight"<Int?>() }.check()
+        df["weight"].cast<Int?>().max().check()
+        (df.max("weight") as Int?).check()
+    }
+
+    @Test
+    fun `nullable minBy`() {
+        val expected = "Alice"
+
+        fun AnyRow?.check() = this!![name] shouldBe expected
+
+        typed.dropNulls { weight }.minBy { weight }.check()
+        typed.dropNulls { it.weight }.minBy { it.weight }.check()
+        typed.minBy { weight }.check()
+
+        df.dropNulls(weight).minBy(weight).check()
+        df.minBy(weight).check()
+
+        df.dropNulls("weight").minBy { "weight"<Int?>() }.check()
+        df.dropNulls("weight").minBy("weight").check()
+        df.minBy("weight").check()
+    }
+
+    @Test
+    fun `maxBy`() {
+        val expected = "Bob"
+
+        fun AnyRow?.check() = this!![name] shouldBe expected
+
+        typed.maxBy { age }.check()
+        typed.maxBy { it.age }.check()
+        typed.maxBy(typed.age).check()
+
+        df.maxBy { age() }.check()
+        df.maxBy(age).check()
+
+        df.maxBy { "age"<Int>() }.check()
+        df.maxBy("age").check()
+    }
+
+    @Test
+    fun `add one column`() {
+        val now = 2020
+        val expected = typed.rows().map { now - it.age }
+
+        fun AnyFrame.check() = this["year"].toList() shouldBe expected
+
+        typed.add("year") { now - age }.check()
+        typed.add("year") { now - it.age }.check()
+
+        df.add("year") { now - age }.check()
+
+        df.add("year") { now - "age"<Int>() }.check()
+    }
+
+    @Test
+    fun `add several columns`() {
+        val now = 2020
+        val expected = typed.rows().map { now - it.age }
+        val g by columnGroup()
+
+        val df = typed.add {
+            "a" from { now - age }
+            "b" from now - age
+            now - age into "c"
+            "d" {
+                "f" from { now - age }
+            }
+            group {
+                g from {
+                    add(age.map { now - it }.named("h"))
+                }
+            } into "e"
+        }.remove { allBefore("a") }
+
+        df.columnNames() shouldBe listOf("a", "b", "c", "d", "e")
+        df["d"].kind() shouldBe ColumnKind.Group
+        df["e"].kind() shouldBe ColumnKind.Group
+        df.getColumnGroup("d").columnNames() shouldBe listOf("f")
+        df.getColumnGroup("e").getColumnGroup("g").columnNames() shouldBe listOf("h")
+        val cols = df.getColumns { colsAtAnyDepth { !it.isColumnGroup() } }
+        cols.size shouldBe 5
+        cols.forEach {
+            it.toList() shouldBe expected
+        }
+    }
+
+    @Test
+    fun `add several columns with type inference`() {
+        val f: Any = 123
+        val df = typed.add {
+            expr(infer = Infer.Type) { f } into "f"
+        }
+        df["f"].type() shouldBe typeOf<Int>()
+    }
+
+    @Test
+    fun `remove one column`() {
+        val expected = listOf("name", "city", "weight")
+
+        fun check(body: () -> AnyFrame) = body().columnNames() shouldBe expected
+
+        check { typed - { age } }
+        check { typed - { it.age } }
+        check { typed.remove { age } }
+        check { typed.remove { it.age } }
+
+        check { df - { age } }
+        check { df - age }
+        check { df.remove(age) }
+
+        check { df - "age" }
+        check { df.remove("age") }
+    }
+
+    @Test
+    fun `remove two columns`() {
+        val expected = listOf("name", "city")
+
+        fun check(body: () -> AnyFrame) = body().columnNames() shouldBe expected
+
+        check { typed - { age and weight } }
+        check { typed - { it.age and it.weight } }
+        check { typed - { age } - { weight } }
+        check { typed - { it.age } - { it.weight } }
+        check { typed.remove { age and weight } }
+        check { typed.remove { it.age and it.weight } }
+
+        check { df - { age and weight } }
+        check { df - age - weight }
+        check { df - { age } - { weight } }
+        check { df.remove(age, weight) }
+
+        check { df - { "age" and "weight" } }
+        check { df - "age" - "weight" }
+        check { df.remove("age", "weight") }
+    }
+
+    @Test
+    fun `merge similar dataframes`() {
+        val res = typed.concat(typed, typed)
+        res.name.size() shouldBe 3 * typed.nrow
+        res.rows().forEach { it.values() shouldBe typed[it.index % typed.nrow].values() }
+    }
+
+    @Test
+    fun `merge different dataframes`() {
+        val height by column<Int>()
+        val heightOrNull = height.nullable()
+
+        @Suppress("ktlint:standard:argument-list-wrapping")
+        val other = dataFrameOf(name, height)(
+            "Bill", 135,
+            "Charlie", 160,
+        ).cast<Unit>()
+
+        val res = typed.concat(other)
+        res.nrow shouldBe typed.nrow + other.nrow
+        res.take(typed.nrow).rows().forEach { it[heightOrNull] == null }
+        val q = res.takeLast(other.nrow)
+        q.rows().forEach { it[name] shouldBe other[it.index][name] }
+        q.rows().forEach { it[heightOrNull] shouldBe other[it.index][height] }
+    }
+
+    @Test
+    fun `row to frame`() {
+        typed[1].toDataFrame().name.size() shouldBe 1
+    }
+
+    @Test
+    fun `compare comparable`() {
+        val new = df.add("date") { LocalDate.now().minusDays(index.toLong()) }
+        val date by column<LocalDate>()
+        new.filter { date >= LocalDate.now().minusDays(3) }.nrow shouldBe 4
+    }
+
+    @Test
+    fun `union dataframes with different type of the same column`() {
+        val df2 = dataFrameOf("age")(32.6, 56.3, null)
+        df2["age"].type() shouldBe typeOf<Double?>()
+        val merged = df.concat(df2)
+        merged["age"].type() shouldBe typeOf<Number?>()
+        val updated = merged.convert("age") { "age"<Number?>()?.toDouble() }
+        updated["age"].type() shouldBe typeOf<Double?>()
+    }
+
+    @Test
+    fun `distinct`() {
+        val expected = 6
+        typed.countDistinct { name and city } shouldBe expected
+        typed.select { name and city }.distinct().nrow shouldBe expected
+        typed.select { name and city }.countDistinct() shouldBe expected
+        val d = typed.distinct { name and city }
+        d.nrow shouldBe expected
+        d.ncol shouldBe 2
+    }
+
+    @Test
+    fun `distinct by`() {
+        typed.distinctBy { name }.nrow shouldBe 3
+        typed.distinctBy { name and city }.nrow shouldBe 6
+        typed.distinctBy { expr { age / 10 } }.nrow shouldBe 4
+        typed.distinctBy { age / 10 }.nrow shouldBe 4
+        typed.distinctBy { expr { city?.get(0) } }.nrow shouldBe 5
+    }
+
+    @Test
+    fun `addRow`() {
+        val res = typed.append("Bob", null, "Paris", null)
+        res.nrow shouldBe typed.nrow + 1
+        res.name.type() shouldBe typeOf<String>()
+        res.age.type() shouldBe typeOf<Int?>()
+        res.city.type() shouldBe typeOf<String?>()
+        res.weight.type() shouldBe typeOf<Int?>()
+
+        val row = res.last()
+        row.name shouldBe "Bob"
+        row["age"] shouldBe null
+        row.city shouldBe "Paris"
+        row.weight shouldBe null
+    }
+
+    @Test
+    fun `rename`() {
+        fun AnyFrame.check() {
+            this["name2"].toList() shouldBe typed.name.toList()
+            this["age2"].toList() shouldBe typed.age.toList()
+            this.columnNames() shouldBe listOf("name2", "age2", "city", "weight")
+            this.getColumnOrNull("age") shouldBe null
+        }
+        typed.rename("name" to "name2", "age" to "age2").check()
+        typed.rename { name and age }.into("name2", "age2").check()
+        typed.rename { name and age }.into { it.name + "2" }.check()
+    }
+
+    @Test
+    fun `select with rename`() {
+        val expected = typed.select { name and age }.rename { all() }.into { it.name + 2 }
+        typed.select { name into "name2" and age.into("age2") } shouldBe expected
+    }
+
+    @Test
+    fun `nunique`() {
+        typed.name.countDistinct() shouldBe 3
+    }
+
+    @Test
+    fun `encode names`() {
+        val encoding = typed.name.distinct().addId("name_id")
+        val res = typed.leftJoin(encoding)
+        res["name_id"].toList() shouldBe listOf(0, 1, 2, 2, 1, 0, 2)
+    }
+
+    @Test
+    fun `pivot matches`() {
+        val pivoted = typed.pivot { city }.groupBy { name and age and weight }.matches()
+        pivoted.ncol shouldBe 4
+        typed.ncol + typed.city.countDistinct() - 1
+        val data = pivoted.getColumnGroup("city")
+        for (row in 0 until typed.nrow) {
+            val city = typed[row][city].toString()
+            data[city][row] shouldBe true
+            for (col in 0 until data.ncol) {
+                val column = data.getColumn(col)
+                val pivotedValue = column.cast<Boolean>()[row]
+                val colName = column.name()
+                pivotedValue shouldBe (colName == city)
+            }
+        }
+    }
+
+    @Test
+    fun `pivot matches equality`() {
+        val res1 = typed.pivot { city }.groupBy { name }.matches()
+        val res2 = typed.groupBy { name }.pivot { city }.matches()
+        val res3 = typed.groupBy { name }.aggregate {
+            pivot { city }.matches()
+        }
+        res2 shouldBe res1
+        res3 shouldBe res1
+    }
+
+    @Test
+    fun `pivot matches with conversion`() {
+        val filtered = typed.dropNulls { city }
+        val res = filtered.pivot(inward = false) { city.lowercase() }.groupBy { name and age }.matches()
+        val cities = filtered.city.toList().map { it!!.lowercase() }
+        val gathered =
+            res.gather { colsOf<Boolean> { cities.contains(it.name()) } }.where { it }.keysInto("city")
+        val expected = filtered.select { name and age and city.map { it!!.lowercase() } }.moveToRight { city }
+        gathered shouldBe expected
+    }
+
+    @Test
+    fun `pivot matches distinct rows`() {
+        val res = typed.pivot(inward = false) { city }.groupBy { name and age }.matches()
+        res.ncol shouldBe 2 + typed.city.countDistinct()
+        for (i in 0 until typed.nrow) {
+            val city = typed[i][city]
+            for (j in typed.ncol until res.ncol) {
+                val col = res.getColumn(j)
+                col.cast<Boolean>().get(i) shouldBe (col.name() == city.toString())
+            }
+        }
+    }
+
+    @Test
+    fun `pivot matches merged rows`() {
+        val selected = typed.select { name and city }
+        val res = typed.pivot(inward = false) { city }.groupBy { name }.matches()
+
+        res.ncol shouldBe selected.city.countDistinct() + 1
+        res.nrow shouldBe selected.name.countDistinct()
+        val trueValuesCount = res.columns().drop(1).sumOf { it.cast<Boolean>().toList().count { it } }
+        trueValuesCount shouldBe selected.distinct().nrow
+
+        val pairs = (1 until res.ncol).flatMap { i ->
+            val col = res.getColumn(i).cast<Boolean>()
+            res.filter { it[col] }.rows().map { it.name to col.name() }
+        }.toSet()
+
+        pairs shouldBe typed.rows().map { it.name to it.city.toString() }.toSet()
+    }
+
+    @Test
+    fun `pivot to matrix`() {
+        val other by column<String>()
+        val others = other.cast<List<String>>()
+        val sum by column<Int>()
+
+        val names = typed.name.distinct().toList()
+
+        val src = typed.select { name }
+            .add(others) { names }
+            .split { others }.intoRows()
+            .add(sum) { name.length + other().length }
+
+        val matrix = src.pivot { other }.groupBy { name }.with { sum }
+        matrix.getColumnGroup(other.name()).ncol shouldBe names.size
+    }
+
+    @Test
+    fun `gather bool`() {
+        val pivoted = typed.pivot { city }.groupBy { name }.matches()
+        val res = pivoted.gather { colsAtAnyDepth().colsOf<Boolean>() }.where { it }.keysInto("city")
+        val sorted = res.sortBy { name and city }
+        sorted shouldBe typed.select { name and city.map { it.toString() } }.distinct().sortBy { name and city }
+    }
+
+    @Test
+    fun `gather nothing`() {
+        val gat = typed.gather { city and name }
+
+        gat.where { false }.into("key", "value")
+            .print()
+    }
+
+    @Test
+    fun `merge rows keep nulls`() {
+        val merged = typed.select { name and city }.implode(dropNA = false) { city }
+
+        val cityList = column<List<String?>>().named("city")
+        merged[cityList].sumOf { it.size } shouldBe typed.city.size
+        merged[cityList].type() shouldBe typeOf<List<String?>>()
+
+        val expected = typed.groupBy { name }.aggregate { it.city.toSet() into "city" }
+        val actual = merged.convert(cityList).with { it.toSet() }
+
+        actual shouldBe expected
+
+        // check that default value for 'dropNulls' is false
+        typed.select { name and city }.implode { city } shouldBe merged
+    }
+
+    @Test
+    fun `merge rows drop nulls`() {
+        val merged = typed.select { name and city }.implode(dropNA = true) { city }
+
+        val cityList = column<List<String>>().named("city")
+        merged[cityList].sumOf { it.size } shouldBe typed.city.dropNulls().size
+        merged[cityList].type() shouldBe typeOf<List<String>>()
+
+        val expected =
+            typed.dropNulls { city }.groupBy { name }.aggregate { it.city.toSet() as Set<String> into "city" }
+        val actual = merged.convert { cityList }.with { it.toSet() }
+
+        actual shouldBe expected
+    }
+
+    @Test
+    fun splitRows() {
+        val selected = typed.select { name and city }
+        val nested = selected.implode(dropNA = false) { city }
+        val mergedCity = column<List<String?>>("city")
+        val res = nested.split { mergedCity }.intoRows()
+        res.sortBy { name } shouldBe selected.sortBy { name }
+    }
+
+    @Test
+    fun mergeCols() {
+        val merged = typed.merge { age and city and weight }.into("info")
+        merged.ncol shouldBe 2
+        merged.nrow shouldBe typed.nrow
+        for (row in 0 until typed.nrow) {
+            val list = merged[row]["info"] as List<Any?>
+            list.size shouldBe 3
+            list[0] shouldBe typed.age[row]
+            list[1] shouldBe typed.city[row]
+            list[2] shouldBe typed.weight[row]
+        }
+    }
+
+    @Test
+    fun joinColsToString() {
+        val merged = typed.merge { age and city and weight }.by(", ").into("info")
+        merged.ncol shouldBe 2
+        merged.nrow shouldBe typed.nrow
+        for (row in 0 until typed.nrow) {
+            val joined = merged[row]["info"] as String
+            joined shouldBe typed.age[row].toString() + ", " + typed.city[row] + ", " + typed.weight[row]
+        }
+    }
+
+    @Test
+    fun mergeIntoList() {
+        val parsed = typed
+            .merge { age and city and weight }.by(", ").intoList()
+            .toDataFrame { "data" from { it } }
+            .split("data").by(", ").into(age, city, weight)
+            .parse(ParserOptions(nullStrings = setOf("null")))
+
+        val expected = typed[age, city, weight]
+        parsed shouldBe expected
+    }
+
+    @Test
+    fun mergeColsCustom() {
+        val merged = typed
+            .merge { name and city and age }
+            .by { it[0].toString() + " from " + it[1] + " aged " + it[2] }
+            .into("info")
+        merged.ncol shouldBe 2
+        merged.nrow shouldBe typed.nrow
+        merged[0]["info"] shouldBe "Alice from London aged 15"
+    }
+
+    @Test
+    fun mergeColsCustom2() {
+        val merged = typed.merge { name and city and age }.by { "$name from $city aged $age" }.into("info")
+        merged.ncol shouldBe 2
+        merged.nrow shouldBe typed.nrow
+        merged[0]["info"] shouldBe "Alice from London aged 15"
+    }
+
+    @Test
+    fun splitCol() {
+        val merged = typed.merge { age and city and weight }.into("info")
+        val info by column<List<Any>>()
+        val res = merged.split(info).into("age", "city", "weight")
+        res shouldBe typed
+    }
+
+    @Test
+    fun splitMergeFrameCol() {
+        val groups by frameColumn()
+        val grouped = typed.groupBy { name }.into(groups)
+        val split = grouped.split(groups).into { "rec$it" }
+        val merged = split.merge { drop(1) }.notNull().into(groups)
+        merged shouldBe grouped
+    }
+
+    @Test
+    fun splitStringCol() {
+        val merged = typed.merge { age and city and weight }.by(" - ").into("info")
+        val info by column<String>()
+        val res = merged.split { info }.by("-").into("age", "city", "weight")
+        val expected = typed.convert { age and city and weight }.with { it.toString() }
+        res shouldBe expected
+    }
+
+    @Test
+    fun splitStringCol2() {
+        val merged = typed.merge { age and city and weight }.by(",").into("info")
+        val info by column<String>()
+        val res = merged.split(info).into("age", "city", "weight")
+        val expected = typed.convert { age and city and weight }.with { it.toString() }
+        res shouldBe expected
+    }
+
+    @Test
+    fun splitStringColGenerateNames() {
+        val merged = typed.merge { age and city and weight }.by(",").into("info")
+        val info by column<String>()
+        val res = merged.split(info).into("age") { "extra$it" }
+        res.columnNames() shouldBe listOf("name", "age", "extra1", "extra2")
+    }
+
+    @Test
+    fun splitStringColWithDefaultgenerator() {
+        val merged = typed.merge { age and city and weight }.by(",").into("info")
+        val info by column<String>()
+        val res = merged.split(info).into("age")
+        res.columnNames() shouldBe listOf("name", "age", "split1", "split2")
+    }
+
+    @Test
+    fun splitAgeIntoDigits() {
+        fun digits(num: Int) =
+            sequence {
+                var k = num
+                while (k > 0) {
+                    yield(k % 10)
+                    k /= 10
+                }
+            }.toList()
+
+        val res = typed.split { age }.by { digits(it) }.into { "digit$it" }
+    }
+
+    @Test
+    fun splitStringCol3() {
+        val merged = typed.merge { age and city and weight }.by(", ").into("info")
+        val info by column<String?>()
+        val res = merged.split(info).by(",").into("age", "city", "weight")
+        val expected = typed.convert { age and city and weight }.with { it.toString() }
+        res shouldBe expected
+    }
+
+    @Test
+    fun splitStringCols() {
+        val merged = typed
+            .merge { name and city }.by(", ").into("nameAndCity")
+            .merge { age and weight }.into("info")
+        val nameAndCity by column<String>()
+        val info by column<List<Number?>>()
+        val res = merged
+            .split { nameAndCity }.into("name", "city")
+            .split(info).into("age", "weight")
+        val expected = typed
+            .update { city }.with { it.toString() }
+            .move { city }.to(1)
+        res shouldBe expected
+    }
+
+    @Test
+    fun `split by with default`() {
+        val res = typed.split { city }.by('o').default("--").into { "a$it" }
+        res.sumOf { values().count { it == "--" } } shouldBe 7
+    }
+
+    @Test
+    fun `merge cols with conversion`() {
+        val pivoted = typed.groupBy { name }.pivot { city }.count()
+        val res = pivoted.merge { city.asColumnGroup().colsOf<Int>() }.by { it.filterNotNull().sum() }.into("cities")
+        val expected = typed.select { name and city }.groupBy { name }.count("cities")
+        res shouldBe expected
+    }
+
+    @Test
+    fun `generic column type`() {
+        val d = typed.convert { city }.with { it?.toCharArray()?.toList() ?: emptyList() }
+        println(d.city.type())
+    }
+
+    @Test
+    fun `column group by`() {
+        fun DataFrame<Person>.check() {
+            ncol shouldBe 3
+            nrow shouldBe typed.nrow
+            columnNames() shouldBe listOf("name", "Int", "String")
+            val intGroup = this["Int"].asColumnGroup()
+            intGroup.columnNames() shouldBe listOf("age", "weight")
+
+            val res = listOf(
+                this.name,
+                this["Int"]["age"],
+                this["String"]["city"],
+                this["Int"]["weight"],
+            ).toDataFrame().cast<Person>()
+            res shouldBe typed
+        }
+        typed.group { cols { it.data != name } }.into { it.type.jvmErasure.simpleName!! }.check()
+        typed.group { age and city and weight }.into { it.type.jvmErasure.simpleName!! }.check()
+    }
+
+    @Test
+    fun `column group`() {
+        val grouped = typed.move { age and name and city }.under("info")
+        grouped.ncol shouldBe 2
+        grouped.columnNames() shouldBe listOf("info", "weight")
+        val res = listOf(
+            grouped["info"]["name"],
+            grouped["info"]["age"],
+            grouped["info"]["city"],
+            grouped.weight,
+        ).toDataFrame().cast<Person>()
+        res shouldBe typed
+    }
+
+    @Test
+    fun `column ungroup`() {
+        val info by columnGroup()
+        val res = typed.move { age and city }.under("info").ungroup { info }
+        res shouldBe typed
+    }
+
+    @Test
+    fun `empty group by`() {
+        val ungrouped = typed.filter { false }.groupBy { name }.concat()
+        ungrouped.nrow shouldBe 0
+        ungrouped.ncol shouldBe 0
+    }
+
+    @Test
+    fun `column stats`() {
+        typed.age.mean() shouldBe typed.age.toList().mean()
+        typed.age.min() shouldBe typed.age.toList().minOrNull()
+        typed.age.max() shouldBe typed.age.toList().maxOrNull()
+        typed.age.sum() shouldBe typed.age.toList().sum()
+    }
+
+    @Test
+    fun `row to string`() {
+        typed[0].toString() shouldBe "{ name:Alice, age:15, city:London, weight:54 }"
+    }
+
+    @Test
+    fun `range slice`() {
+        typed[3..5].name.toList() shouldBe typed.name.toList().subList(3, 6)
+    }
+
+    @Test
+    fun `range slice two times`() {
+        typed[3..5][1..2].name.toList() shouldBe typed.name.toList().subList(4, 6)
+    }
+
+    @Test
+    fun `move to position`() {
+        typed.getColumn(1) shouldBe typed.age
+        val moved = typed.move { age }.to(2)
+        moved.getColumn(2) shouldBe typed.age
+        moved.ncol shouldBe typed.ncol
+    }
+
+    @Test
+    fun `forEachIn`() {
+        val pivoted = typed.pivot(inward = true) { city }.groupBy { name and weight }.with { age }
+        val sum = pivoted
+            .select { "city".allCols() }
+            .values()
+            .filterNotNull()
+            .sumOf { it as Int }
+        sum shouldBe typed.age.sum()
+    }
+
+    @Test
+    fun `parse`() {
+        val toStr = typed.convert { weight }.notNull { it.toString() }
+        val weightStr = "weight".toColumnOf<String?>()
+        val parsed = toStr.convert { weightStr }.toInt()
+        parsed shouldBe typed
+    }
+
+    @Test
+    fun digitize() {
+        val a = 20
+        val b = 40
+        val expected = typed.age.toList().map {
+            when {
+                it < a -> 0
+                it < b -> 1
+                else -> 2
+            }
+        }
+        typed.age.digitize(a, b).toList() shouldBe expected
+
+        val expectedRight = typed.age.toList().map {
+            when {
+                it <= a -> 0
+                it <= b -> 1
+                else -> 2
+            }
+        }
+        typed.age.digitize(a, b, right = true).toList() shouldBe expectedRight
+    }
+
+    @Test
+    fun corr() {
+        val fixed = typed.fillNulls { weight }.with { 60 }
+        val res = fixed.corr()
+        res.ncol shouldBe 3
+        res.nrow shouldBe 2
+        res["age"][0] shouldBe 1.0
+        res["weight"][0] shouldBe res["age"][1]
+        res["weight"][0] as Double should ToleranceMatcher(0.9, 1.0)
+    }
+
+    @Test
+    fun `aggregate into grouped column`() {
+        val d = typed.groupBy { name }.aggregate {
+            val row = meanFor { age and weight }
+            row into "mean"
+        }
+        d.ncol shouldBe 2
+        d["mean"].isColumnGroup() shouldBe true
+        val mean = d.getColumnGroup("mean")
+        mean.ncol shouldBe 2
+        mean.columnNames() shouldBe listOf("age", "weight")
+        mean.columns().forEach {
+            it.type() shouldBe typeOf<Double>()
+        }
+    }
+
+    @Test
+    fun `mean for all columns`() {
+        val d = typed.groupBy { name }.mean()
+        d.columnNames() shouldBe listOf("name", "age", "weight")
+        d.nrow shouldBe typed.name.countDistinct()
+        d["age"].type() shouldBe typeOf<Double>()
+        d["weight"].type() shouldBe typeOf<Double>()
+    }
+
+    @Test
+    fun `aggregate into table column`() {
+        val d = typed.groupBy { name }.aggregate {
+            val row = select { age and weight }
+            row into "info"
+        }
+        d.ncol shouldBe 2
+        d["info"].isFrameColumn() shouldBe true
+        val info = d.getFrameColumn("info")
+        info.forEach {
+            it.ncol shouldBe 2
+            it.columnNames() shouldBe listOf("age", "weight")
+            it.columns().forEach {
+                it.typeClass shouldBe Int::class
+            }
+        }
+    }
+
+    @Test
+    fun `union table columns`() {
+        val grouped = typed.addId("id").groupBy { name }.toDataFrame()
+        val flattened = (0 until grouped.nrow).map {
+            grouped[it..it]
+        }
+        val dst = flattened
+            .concat().asGroupBy()
+            .concat()
+            .sortBy("id")
+            .remove("id")
+        dst shouldBe typed
+    }
+
+    @Test
+    fun `columns sum`() {
+        val name by columnOf("Alice", "Bob", "Charlie")
+        val age by columnOf(15, 20, 24)
+        val df = dataFrameOf(name, age)
+
+        df.columnNames() shouldBe listOf("name", "age")
+        df.nrow shouldBe 3
+    }
+
+    @Test
+    fun convert1() {
+        val res = typed.convert { age }.to<Double>()
+        res.age.typeClass shouldBe Double::class
+        res["age"].all { it is Double } shouldBe true
+    }
+
+    @Test
+    fun convert2() {
+        val res = typed.convert { weight }.to<BigDecimal?>()
+        res.weight.typeClass shouldBe BigDecimal::class
+        res["weight"].all { it == null || it is BigDecimal } shouldBe true
+    }
+
+    @Test
+    fun convert3() {
+        val res = typed.convert { all() }.to<String?>()
+        res.columns().forEach { it.typeClass shouldBe String::class }
+        res.columns().map { it.hasNulls() } shouldBe typed.columns().map { it.hasNulls() }
+    }
+
+    @Test
+    fun replace() {
+        val res = typed.replace { age }.with(2021 - typed.age)
+        val expected = typed.update { age }.with { 2021 - age }
+        res shouldBe expected
+    }
+
+    @Test
+    fun `replace with rename`() {
+        val res = typed.replace { age }.with { it.rename("age2") }
+        res shouldBe typed.rename { age }.into("age2")
+    }
+
+    @Test(expected = IllegalArgumentException::class)
+    fun `replace exception`() {
+        typed.replace { colsOf<Int?>() }.with(typed.name)
+    }
+
+    @Test
+    fun `replace two columns`() {
+        val res = typed.replace { age and weight }.with(typed.age * 2, typed.weight * 2)
+        val expected = typed.update { age and weight }.with { it?.times(2) }
+        res shouldBe expected
+    }
+
+    @Test
+    fun `replace with expression`() {
+        val res = typed.replace { age }.with { 2021 - age named "year" }
+        val expected = typed
+            .convert { age }.with { 2021 - age }
+            .rename { age }.into("year")
+        res shouldBe expected
+    }
+
+    @Test
+    fun `add dataframe`() {
+        val first = typed.select { name and age }
+        val second = typed.select { city and weight }
+        first.add(second) shouldBe typed
+        first.addAll(second.columns()) shouldBe typed
+        first + second.columns() shouldBe typed
+    }
+
+    @Test
+    fun explodeLists() {
+        val df = dataFrameOf("lists")(listOf(1, 2), listOf(3))
+
+        df.explode("lists") shouldBe dataFrameOf("lists")(1, 2, 3)
+    }
+
+    @Test
+    fun splitUnequalLists() {
+        val values by columnOf(1, 2, 3, 4)
+        val list1 by columnOf(listOf(1, 2, 3), listOf(), listOf(1, 2), null)
+        val list2 by columnOf(listOf(1, 2), listOf(1, 2), listOf(1, 2), listOf(1))
+        val df = dataFrameOf(values, list1, list2)
+        val res = df.explode { list1 and list2 }
+        val expected = dataFrameOf(values.name(), list1.name(), list2.name())(
+            1, 1, 1,
+            1, 2, 2,
+            1, 3, null,
+            2, null, 1,
+            2, null, 2,
+            3, 1, 1,
+            3, 2, 2,
+            4, null, 1,
+        )
+        res shouldBe expected
+    }
+
+    @Test
+    fun splitUnequalListAndFrames() {
+        val values by columnOf(1, 2, 3)
+        val list1 by columnOf(listOf(1, 2, 3), listOf(1), listOf(1, 2))
+        val frames by listOf(listOf(1, 2), listOf(1, 2), listOf(1, 2)).map {
+            val data = it.toColumn("data")
+            val dataStr = it.map { it.toString() }.toColumn("dataStr")
+            dataFrameOf(data, dataStr)
+        }.toColumn()
+        frames.kind shouldBe ColumnKind.Frame
+
+        val df = dataFrameOf(values, list1, frames)
+        val res = df.explode { list1 and frames }.ungroup(frames)
+        val expected = dataFrameOf(values.name(), list1.name(), "data", "dataStr")(
+            1, 1, 1, "1",
+            1, 2, 2, "2",
+            1, 3, null, null,
+            2, 1, 1, "1",
+            2, null, 2, "2",
+            3, 1, 1, "1",
+            3, 2, 2, "2",
+        )
+        res shouldBe expected
+    }
+
+    @Test
+    fun `update nullable column with not null`() {
+        val df = dataFrameOf("name", "value")("Alice", 1, null, 2)
+        df.update("name").at(0).with { "ALICE" }
+    }
+
+    @Test(expected = IllegalArgumentException::class)
+    fun `update with wrong type`() {
+        typed.update("age").with { "string" }
+    }
+
+    @Test
+    fun `update with null`() {
+        val updated = typed.update { age }.at(2).withNull()
+        updated.age[2] shouldBe null
+        updated.age.hasNulls shouldBe true
+    }
+
+    @Test
+    fun `update with two conditions`() {
+        fun DataFrame<Person>.check() = indices { age == 100 } shouldBe listOf(1, 3)
+
+        typed
+            .update { age }.at(1..3).where { it > 20 }.with { 100 }
+            .check()
+        typed
+            .update { age }.where { it > 20 }.at(1..3).with { 100 }
+            .check()
+    }
+
+    @Test
+    fun `update nulls`() {
+        typed
+            .update { weight }.where { it == null }.with { 15 }
+            .weight.hasNulls shouldBe false
+    }
+
+    @Test
+    fun `mean all columns`() {
+        typed.mean().values() shouldBe listOf(typed.age.mean(), typed.weight.mean())
+    }
+
+    @Test
+    fun `mean by string`() {
+        typed.mean("weight") shouldBe typed.weight.mean()
+    }
+
+    @Test
+    fun `create column with single string value`() {
+        val frameCol by columnOf(typed, null, typed)
+        frameCol.kind() shouldBe ColumnKind.Frame
+        frameCol.name() shouldBe "frameCol"
+
+        val mapCol by columnOf(typed.name, typed.city)
+        mapCol.kind() shouldBe ColumnKind.Group
+        mapCol.name() shouldBe "mapCol"
+
+        val valueCol = columnOf("Alice") named "person"
+        valueCol.kind() shouldBe ColumnKind.Value
+        valueCol.name() shouldBe "person"
+    }
+
+    @Test
+    fun `append many`() {
+        val res = typed.append(
+            "John", 22,
+            "New York", 46,
+            "Philip", 25,
+            "Chelyabinsk", 36,
+        )
+        res.nrow shouldBe typed.nrow + 2
+    }
+
+    @Test
+    fun `append wrong number of arguments`() {
+        shouldThrow<IllegalStateException> {
+            dataFrameOf("name", "age")(
+                "Alice", 15,
+                "Bob", 20,
+            ).append("John")
+        }
+    }
+
+    @Test
+    fun `first last`() {
+        typed.first() shouldBe typed[0]
+        typed.last() shouldBe typed[typed.nrow - 1]
+        typed.city.first() shouldBe typed[0].city
+        typed.city.last() shouldBe typed[typed.nrow - 1].city
+    }
+
+    @Test
+    fun `select several rows`() {
+        df[2, 5].nrow shouldBe 2
+        df[0, 3, 5] shouldBe df[listOf(0, 3, 5)]
+        df[3, 5][name, age] shouldBe df[name, age][3, 5]
+    }
+
+    @Test
+    fun `select several column values`() {
+        typed.name[2, 5, 6] shouldBe typed.name[listOf(2, 5, 6)]
+    }
+
+    @Test
+    fun `get by column accessors`() {
+        val animal by columnOf("cat", "snake", "dog")
+        val age by columnOf(2.5, 3.0, 0.5)
+        val visits by columnOf(1, 3, 2)
+
+        val df = dataFrameOf(animal, age, visits)
+
+        val d1 = df[1..1][animal, age]
+        d1.ncol shouldBe 2
+        d1.nrow shouldBe 1
+
+        val d2 = df[0..1]["animal", "age"]
+        d2.ncol shouldBe 2
+        d2.nrow shouldBe 2
+
+        val r1 = df[1][animal, age]
+        r1.values() shouldBe d1.single().values()
+
+        val r2 = df[0]["animal", "age"]
+        r2 shouldBe df[animal, age][0]
+    }
+
+    @Test
+    fun between() {
+        typed.filter { age.between(20, 40, false) }.nrow shouldBe 2
+
+        typed.filter { age in 20..40 }.nrow shouldBe 5
+
+        typed.age.between(20, 40).count { it } shouldBe 5
+    }
+
+    @Test
+    fun iterators() {
+        var counter = 0
+        for (a in df) counter++
+        counter shouldBe df.nrow
+
+        var ageSum = 0
+        for (a in typed.age) {
+            ageSum += a
+        }
+
+        ageSum shouldBe typed.age.sum()
+    }
+
+    @Test
+    fun `create with random`() {
+        val df = dataFrameOf('a'..'f').randomInt(3)
+        df.nrow shouldBe 3
+        df.ncol shouldBe ('a'..'f').count()
+        df.columns().forEach { it.type() shouldBe typeOf<Int>() }
+    }
+
+    @Test
+    fun `create with list builder`() {
+        val df = dataFrameOf(4..10 step 2) { h -> List(10) { h } }
+        df.nrow shouldBe 10
+        df.ncol shouldBe 4
+        df.columns().forEach { col -> col.forEach { it shouldBe col.name().toInt() } }
+    }
+
+    @Test
+    fun `create with vararg header and builder`() {
+        val df = dataFrameOf("first", "secon", "third") { name -> name.toCharArray().toList() }
+        df.nrow shouldBe 5
+        df.ncol shouldBe 3
+        df.columns().forEach { col -> col.name() shouldBe col.values().joinToString("") }
+    }
+
+    @Test
+    fun `create with vararg doubles and fill equal`() {
+        val df = dataFrameOf(1.0.toString(), 2.5.toString()).fill(5, true)
+        df.nrow shouldBe 5
+        df.ncol shouldBe 2
+        df.columns().forEach { col -> col.forEach { it shouldBe true } }
+    }
+
+    @Test
+    fun `create with list of names and fill nulls`() {
+        val names = listOf("first", "second")
+        val df = dataFrameOf(names).nulls<Double>(10)
+        df.nrow shouldBe 10
+        df.ncol shouldBe 2
+        df.columns().forEach { col -> (col.type() == typeOf<Double?>() && col.allNulls()) shouldBe true }
+    }
+
+    @Test
+    fun `create with list of names and fill true`() {
+        val first by column<Boolean>()
+        val second by column<Boolean>()
+        val df = dataFrameOf(first, second).fill(5) { true }
+        df.nrow shouldBe 5
+        df.ncol shouldBe 2
+        df.columns().forEach { col -> (col.type() == typeOf<Boolean>() && col.all { it == true }) shouldBe true }
+    }
+
+    @Test
+    fun `create with int range header and int range data `() {
+        val df = dataFrameOf(1..5) { 1..5 }
+        df.nrow shouldBe 5
+        df.ncol shouldBe 5
+        df.columns().forEach { col -> col.forEachIndexed { row, value -> value shouldBe row + 1 } }
+    }
+
+    @Test
+    fun `get typed column by name`() {
+        val col = df.getColumn("name").cast<String>()
+        col[0].substring(0, 3) shouldBe "Ali"
+    }
+
+    @Test
+    fun `select all after`() {
+        typed.select { allAfter(age) } shouldBe typed.select { city and weight }
+        typed.select { allFrom(age) } shouldBe typed.select { age and city and weight }
+        typed.select { allBefore(age) } shouldBe typed.select { name }
+        typed.select { allUpTo(age) } shouldBe typed.select { name and age }
+    }
+
+    @Test
+    fun `cols of type`() {
+        val stringCols = typed.select { colsOf<String?>() }
+        stringCols.columnNames() shouldBe listOf("name", "city")
+    }
+
+    @Test
+    fun `get row value by expression`() {
+        val expression: RowExpression<Person, Int> = { it.age * 2 }
+        val added = typed.add("new") { it[expression] }
+        added shouldBe typed.add("new") { age * 2 }
+    }
+
+    @Test
+    fun `render nested data frames to string`() {
+        val rendered = typed
+            .drop(1)
+            .groupBy { name }
+            .groups
+            .asIterable()
+            .joinToString("\n") { renderValueForStdout(it).truncatedContent }
+        rendered shouldBe
+            """
+            [2 x 4]
+            [3 x 4]
+            [1 x 4] { name:Alice, age:20, weight:55 }
+            """.trimIndent()
+    }
+
+    @Test
+    fun `drop where any na`() {
+        val updated = typed.convert { weight }.with { if (name == "Alice") Double.NaN else it?.toDouble() }
+        val expected = updated.count { city != null && !("weight"<Double?>()?.isNaN() ?: true) }
+
+        fun AnyFrame.check() = nrow shouldBe expected
+
+        updated.dropNA { city and weight }.check()
+        updated.dropNA(city, weight).check()
+        updated.dropNA("city", "weight").check()
+        updated.dropNA(Person::city, Person::weight).check()
+    }
+
+    @Test
+    fun `drop where all na`() {
+        val updated = typed.convert { weight }.with { if (name == "Alice") Double.NaN else it?.toDouble() }
+        val expected = updated.count { city != null || !("weight"<Double?>()?.isNaN() ?: true) }
+
+        fun AnyFrame.check() = nrow shouldBe expected
+
+        updated.dropNA(whereAllNA = true) { city and weight }.check()
+        updated.dropNA(city, weight, whereAllNA = true).check()
+        updated.dropNA("city", "weight", whereAllNA = true).check()
+        updated.dropNA(Person::city, Person::weight, whereAllNA = true).check()
+    }
+
+    @Test
+    fun sortWith() {
+        typed.sortWith { r1, r2 ->
+            when {
+                r1.name < r2.name -> -1
+                r1.name > r2.name -> 1
+                else -> -r1.age.compareTo(r2.age)
+            }
+        } shouldBe typed.sortBy { name and age.desc() }
+
+        val comparator = Comparator<DataRow<Person>> { r1, r2 -> -r1.name.compareTo(r2.name) }
+        typed.sortWith(comparator) shouldBe typed.sortByDesc { name }
+    }
+
+    @Test
+    fun sortByDescDesc() {
+        typed.sortByDesc { name.desc() and age } shouldBe typed.sortBy { name and age.desc() }
+    }
+
+    @Test
+    fun `get column by columnRef with data`() {
+        val col by columnOf(1, 2, 3)
+        val df = col.toDataFrame()
+        df[1..2][col].values() shouldBe listOf(2, 3)
+    }
+
+    @Test
+    fun `get by column`() {
+        typed[1..2].get { typed.age }.size() shouldBe typed.age.size()
+    }
+
+    @Test
+    fun `null column test`() {
+        val df = dataFrameOf("col")(null, null)
+        df["col"].kind() shouldBe ColumnKind.Value
+        df["col"].type() shouldBe nothingType(true)
+    }
+
+    @Test
+    fun `groupBy with map`() {
+        typed
+            .groupBy { name.map { it.lowercase() } }.toDataFrame()
+            .name.values() shouldBe
+            typed.name.distinct().lowercase().values()
+    }
+
+    @Test
+    fun `groupBy none`() {
+        val grouped = typed.groupBy { none() }
+        grouped.keys.ncol shouldBe 0
+        grouped.groups.size shouldBe 1
+        val values = grouped.values()
+        values.nrow shouldBe 1
+        values.columns().forEach {
+            it.typeClass shouldBe List::class
+            (it[0] as List<*>).size shouldBe typed.nrow
+        }
+        values.explode() shouldBe typed
+    }
+
+    @Test
+    fun `pivot max`() {
+        val pivoted = typed.pivot(inward = false) { city }.groupBy { name }.max { age }
+        pivoted.single { name == "Charlie" }["Moscow"] shouldBe 30
+    }
+
+    @Test
+    fun `pivot all values`() {
+        val pivoted = typed.pivot(inward = false) { city }.groupBy { name }.values()
+        pivoted.ncol shouldBe 1 + typed.city.countDistinct()
+        pivoted.columns().drop(1).forEach {
+            it.kind() shouldBe ColumnKind.Group
+            it.asColumnGroup().columnNames() shouldBe listOf("age", "weight")
+        }
+    }
+
+    @Test
+    fun `pivot mean values`() {
+        val pivoted = typed.pivot { city }.groupBy { name }.mean()
+        pivoted.getColumnGroup(1).columns().forEach {
+            it.kind() shouldBe ColumnKind.Group
+            val group = it.asColumnGroup()
+            group.columnNames() shouldBe listOf("age", "weight")
+            group.columns().forEach {
+                it.type() shouldBe typeOf<Double?>()
+            }
+        }
+    }
+
+    @Test
+    fun `aggregate dataframe with pivot`() {
+        val summary = typed.aggregate {
+            count() into "count"
+            pivot { name }.max { age }
+            sum { weight } into "total weight"
+        }
+        val expected = dataFrameOf("count", "Alice", "Bob", "Charlie", "total weight")(7, 20, 45, 40, 354)
+        summary shouldBe expected.group { cols(1..3) }.into("name")[0]
+    }
+
+    @Test
+    fun `pivot grouped max`() {
+        val pivoted = typed.pivot { name }.groupBy { city }.max()
+        pivoted.getColumnGroup("name").columns().forEach {
+            it.kind() shouldBe ColumnKind.Group
+            val group = it.asColumnGroup()
+            group.columnNames() shouldBe listOf("age", "weight")
+        }
+    }
+
+    @Test
+    fun `find the longest string`() {
+        val longestCityName = "Taumatawhakatangihangakoauauotamateaturipukakapikimaungahoronukupokaiwhenuakitanatahu"
+        val updated = typed.update { city }.where { it == "Dubai" }.with { longestCityName }
+        updated.valuesNotNull { colsOf<String?>() }.maxByOrNull { it.length } shouldBe longestCityName
+    }
+
+    @Test
+    fun `sort by expression`() {
+        val sorted = typed.sortBy { expr { name.length }.desc() }
+        sorted.name.values() shouldBe typed.name.values().sortedByDescending { it.length }
+    }
+
+    @Test
+    fun `grouped sort by count`() {
+        val sorted = typed.groupBy { name }.sortByCount()
+        sorted.toDataFrame().name.values() shouldBe
+            typed.rows()
+                .groupBy { it.name }
+                .toList()
+                .sortedByDescending { it.second.size }
+                .map { it.first }
+    }
+
+    @Test
+    fun `grouped sort by key`() {
+        val sorted = typed.groupBy { name }.sortByKey()
+        sorted.toDataFrame().name.values() shouldBe
+            typed.name
+                .distinct()
+                .values()
+                .sorted()
+    }
+
+    @Test
+    fun `infer ColumnGroup type in convert with`() {
+        val g by frameColumn()
+        val grouped = typed
+            .groupBy { name }.toDataFrame(g.name)
+            .convert(g).with { it.first() }
+        grouped[g.name].kind() shouldBe ColumnKind.Group
+    }
+
+    @Test
+    fun `filter GroupBy by groups`() {
+        val grouped = typed.groupBy { name }
+        val filtered = grouped.filter { group.nrow > 2 }.concat()
+        filtered shouldBe typed.filter { name == "Charlie" }
+    }
+
+    @Test
+    fun `split inplace`() {
+        val split = typed.split { name }.by { it.toCharArray().asIterable() }.inplace()
+        split["name"] shouldBe typed.name.map { it.toCharArray().toList() }
+    }
+
+    @Test
+    fun `split into rows with transform`() {
+        val split = typed.split { city }.by { it.toCharArray().toList() }.intoRows()
+        split.nrow shouldBe typed.city.sumOf { it?.length ?: 0 }
+    }
+
+    @Test
+    fun `render to string`() {
+        val expected =
+            """
+                 name age   city weight
+            0   Alice  15 London     54
+            1     Bob  45  Dubai     87
+            2 Charlie  20 Moscow   null
+            3 Charlie  40  Milan   null
+            4     Bob  30  Tokyo     68
+            5   Alice  20   null     55
+            6 Charlie  30 Moscow     90
+            """.trimIndent()
+
+        typed.toString().trimIndent() shouldBe expected
+    }
+
+    @Test
+    fun `isNumber`() {
+        typed.age.isNumber() shouldBe true
+        typed.weight.isNumber() shouldBe true
+
+        DataColumn.createValueColumn("a", emptyList<Nothing>(), nothingType(false)).isNumber() shouldBe true
+        DataColumn.createValueColumn("a", listOf(null), nothingType(true)).isNumber() shouldBe true
+    }
+
+    @Test
+    fun `pivot null to default`() {
+        val pivoted = typed
+            .groupBy { name }.pivot { city }.default(0).min { weight }
+        pivoted.columns().forEach {
+            it.hasNulls() shouldBe false
+        }
+    }
+
+    @Test
+    fun `iterable to column`() {
+        val ref by column<String>()
+        val col = listOf("a", null).toColumn(ref)
+        col.hasNulls() shouldBe true
+    }
+
+    @Test
+    fun `columnAccessor map linear`() {
+        // SampleStart
+        val age by column<Int>()
+        var counter = 0
+        val year by age.map {
+            counter++
+            2021 - it
+        }
+        df.filter { year > 2000 }.nrow shouldBe 3
+        counter shouldBe df.nrow
+        // SampleEnd
+    }
+
+    @Test
+    fun convertTo() {
+        data class Target(
+            val name: String,
+            val age: Int,
+            val city: String?,
+            val weight: Int?,
+        )
+
+        df.convertTo<Target>() shouldBe df
+        df.convert { age }.toStr().convertTo<Target>() shouldBe df
+        df.add("col") { 1 }.convertTo<Target>(ExcessiveColumns.Remove) shouldBe df
+
+        val added = df.add("col") { 1 }
+        added.convertTo(typeOf<Target>(), ExcessiveColumns.Keep) shouldBe added
+
+        df.remove { city }.convertTo<Target>() shouldBe
+            df.update { city }.withNull()
+                .move { city }.toRight()
+
+        shouldThrow<IllegalArgumentException> {
+            df.remove { age }.convertTo<Target>()
+        }
+
+        df.remove { age }.convertTo<Target> {
+            fill { age }.with { -1 }
+        } shouldBe
+            df.update { age }.with { -1 }
+                .move { age }.toRight()
+
+        shouldThrow<TypeConversionException> {
+            df.update { name }.at(2).withNull()
+                .convertTo<Target>()
+        }
+
+        shouldThrow<IllegalArgumentException> {
+            df.convert { age }.toStr().convertToImpl(
+                typeOf<Target>(),
+                allowConversion = false,
+                ExcessiveColumns.Remove,
+            )
+        }
+
+        shouldThrow<ExcessiveColumnsException> {
+            df.add("col") { 1 }.convertTo<Target>(ExcessiveColumns.Fail) shouldBe df
+        }
+
+        val list = df.toListOf<Target>()
+        list shouldBe df.convertTo<Target>().toList()
+
+        val listDf = list.toDataFrame()
+        listDf shouldBe df
+        listDf.toList() shouldBe list
+    }
+
+    @Test
+    fun typedFrameColumn() {
+        @DataSchema
+        data class Student(val name: String, val age: Int, val weight: Int?)
+
+        @DataSchema
+        data class Target(val city: String?, val students: List<Student>)
+
+        val grouped = df.groupBy { city }.toDataFrame("students")
+
+        val list = grouped.toListOf<Target>()
+        list shouldBe grouped.convertTo<Target>().toList()
+
+        val listDf = list.toDataFrame(maxDepth = 2)
+        listDf shouldBe grouped.update { getFrameColumn("students") }.with { it.remove("city") }
+
+        listDf.toList() shouldBe list
+    }
+
+    @Test
+    fun reorderColumns() {
+        typed.reorderColumnsByName().columnNames() shouldBe typed.columnNames().sorted()
+        val grouped = typed.groupBy { city }.into("a").reorderColumnsByName()
+        grouped.columnNames() shouldBe listOf("a", "city")
+        grouped.getFrameColumn("a")[0].columnNames() shouldBe typed.columnNames().sorted()
+    }
+
+    @Test
+    fun typedColumnGroup() {
+        @DataSchema
+        data class Info(val age: Int, val weight: Int?)
+
+        @DataSchema
+        data class Target(val name: String, val info: Info, val city: String?)
+
+        val grouped = typed.group { age and weight }.into("info")
+
+        val list = grouped.toListOf<Target>()
+        list shouldBe grouped.convertTo<Target>().toList()
+
+        val listDf = list.toDataFrame(maxDepth = 2)
+        listDf shouldBe grouped
+        listDf.toList() shouldBe list
+    }
+
+    @Test
+    fun splitWithRegex() {
+        val data by column<String>()
+        val merged = typed.merge { name and city }.by("|").into(data)
+        merged.split { data }.match("""(.*)\|(.*)""".toRegex()).into("name", "city") shouldBe
+            typed.update { city }.with { it ?: "null" }
+                .move { city }.to(1)
+    }
+
+    @Test
+    fun splitIntoThisAndNewColumn() {
+        val split = typed.split { name }.by { listOf(it.dropLast(1), it.last()) }.into("name", "lastChar")
+        split.columnNames().sorted() shouldBe (typed.columnNames() + "lastChar").sorted()
+    }
+
+    @Test
+    fun groupByAggregateSingleColumn() {
+        val agg = typed.groupBy { name }.aggregate { city into "city" }
+        agg shouldBe typed.groupBy { name }.values { city }
+        agg["city"].type shouldBe typeOf<List<String?>>()
+    }
+
+    @Test
+    fun implodeWithNulls() {
+        val merged = typed
+            .update { weight }.where { name == "Charlie" }.withNull()
+            .select { name and weight }
+            .implode(dropNA = true) { weight }
+
+        merged["weight"].type() shouldBe typeOf<List<Int>>()
+    }
+
+    @Test
+    fun updateWithZero() {
+        val updated = typed
+            .convert { weight }.toDouble()
+            .update { colsOf<Number?>() }.where { name == "Charlie" }.withZero()
+        updated.age.type shouldBe typeOf<Int>()
+        updated["weight"].type shouldBe typeOf<Double>()
+        val filtered = updated.filter { name == "Charlie" }
+        filtered.nrow shouldBe 3
+        filtered.age.forEach {
+            it shouldBe 0
+        }
+        filtered["weight"].forEach {
+            it shouldBe .0
+        }
+    }
+
+    @Test
+    fun map() {
+        val mapped = typed.mapToFrame {
+            name into "name"
+            "year" from 2021 - age
+            "CITY" from { city?.uppercase() }
+        }
+        mapped.columnNames() shouldBe listOf("name", "year", "CITY")
+    }
+
+    @Test
+    fun `groupByGroup name clash`() {
+        val groupName = GroupBy.groupedColumnAccessor.name()
+        typed.add(groupName) { name }
+            .groupBy(groupName).toDataFrame()
+            .ncol shouldBe 2
+    }
+
+    @Test
+    fun describe() {
+        val desc = typed
+            .group { age and weight }.into("info")
+            .groupBy { city }.toDataFrame()
+            .describe()
+        desc.nrow shouldBe typed.ncol + 1
+        desc["type"][0] shouldBe "String?"
+        desc["path"][1] shouldBe listOf("group", "name")
+        desc["name"][0] shouldBe "city"
+        desc["count"][3] shouldBe 7
+        desc["unique"][4] shouldBe 6
+        desc["nulls"][3] shouldBe 2
+        desc["top"][0] shouldBe "London"
+        desc["mean"][2] shouldBe 28.571428571428573
+        desc["std"][2] shouldBe 11.073348527841414
+        desc["min"][2] shouldBe 15
+        desc["median"][2] shouldBe 30
+        desc["max"][2] shouldBe 45
+        desc.print()
+    }
+
+    @DataSchema
+    data class ComparableTest(
+        val int: Int,
+        val comparableInt: Comparable<Int>,
+        val string: String,
+        val comparableString: Comparable<String>,
+        val comparableStar: Comparable<*>,
+        val comparableNothing: Comparable<Nothing>,
+    )
+
+    @Test
+    fun `is comparable`() {
+        val df = listOf(
+            ComparableTest(1, 1, "a", "a", 1, 1),
+            ComparableTest(2, 2, "b", "b", "2", "2"),
+        ).toDataFrame()
+
+        df.int.isComparable() shouldBe true
+        df.comparableInt.isComparable() shouldBe true
+        df.string.isComparable() shouldBe true
+        df.comparableString.isComparable() shouldBe true
+        df.comparableStar.isComparable() shouldBe false
+        df.comparableNothing.isComparable() shouldBe false
+    }
+
+    @Test
+    fun `describe twice minimal`() {
+        val df = dataFrameOf("a", "b")(1, "foo", 3, "bar")
+        val desc1 = df.describe()
+        val desc2 = desc1.describe()
+        desc2::class shouldBe DataFrameImpl::class
+    }
+
+    @Test
+    fun `describe twice`() {
+        val df = typed
+            .group { age and weight }.into("info")
+            .groupBy { city }.toDataFrame()
+        val desc1 = df.describe()
+        val desc2 = desc1.describe()
+        desc2::class shouldBe DataFrameImpl::class
+    }
+
+    @Test
+    fun `index by column accessor`() {
+        val col = listOf(1, 2, 3, 4, 5).toColumn("name")
+        col.toDataFrame()[1..2][col].size shouldBe 2
+
+        val col2 = columnOf(1, 2, 3, 4, 5) named "name"
+        col2.toDataFrame()[1..2][col2].size shouldBe 2
+
+        val col3 by columnOf(1, 2, 3, 4, 5)
+        col3.toDataFrame()[1..2][col3].size shouldBe 2
+
+        val col4 by listOf(1, 2, 3, 4, 5).toColumn()
+        col4.toDataFrame()[1..2][col4].size shouldBe 2
+    }
+
+    @Test
+    fun `take drop in columns selector`() {
+        typed.select { take(3) } shouldBe typed.select { cols(0..2) }
+        typed.select { takeLast(2) } shouldBe typed.select { cols(2..3) }
+        typed.select { drop(1) } shouldBe typed.select { cols(1..3) }
+        typed.select { dropLast(1) } shouldBe typed.select { cols(0..2) }
+    }
+
+    @Test
+    fun `except in columns selector`() {
+        typed.select { allExcept { age and weight } } shouldBe typed.select { name and city }
+
+        typed
+            .group { age and weight and city }.into("info")
+            .alsoDebug()
+            .select { allExcept { "info"["age"] } }
+            .alsoDebug()
+            .let {
+                it.name shouldBe typed.name
+                it["info"]["weight"] shouldBe typed.weight
+                it["info"]["city"] shouldBe typed.city
+            }
+    }
+
+    @Test
+    fun `get by empty path`() {
+        val all = typed[pathOf()]
+
+        all.asColumnGroup().asDataFrame().columns() shouldBe typed.columns()
+
+        typed.getColumn { emptyPath() } shouldBe all
+    }
+
+    @Test
+    fun `update frame column to null`() {
+        val grouped = typed.groupBy { name }.toDataFrame("group")
+        grouped["group"].kind shouldBe ColumnKind.Frame
+        val updated = grouped.update("group").at(2).withNull()
+        updated["group"].kind shouldBe ColumnKind.Value
+    }
+
+    @Test
+    fun `merge into same name`() {
+        typed.merge { name and city }.into("age") shouldBe
+            typed
+                .merge { name and city }.into("data")
+                .remove("age")
+                .rename("data" to "age")
+    }
+
+    @Test
+    fun `groupBy sort`() {
+        typed
+            .groupBy { name }.sortByDesc { age }.xs("Charlie").concat() shouldBe
+            typed
+                .filter { name == "Charlie" }
+                .sortBy { age.desc() }
+                .remove { name }
+    }
+
+    @Test
+    fun `split into columns`() {
+        val group by frameColumn()
+        typed
+            .groupBy { name }.into(group)
+            .split(group).intoColumns()
+    }
+
+    @Test
+    fun `takedrop for column`() {
+        typed.age.take(2) shouldBe typed.age[0..1]
+        typed.age.drop(2) shouldBe typed.age[2 until typed.nrow]
+        typed.age.takeLast(2) shouldBe typed.age.drop(typed.nrow - 2)
+        typed.age.dropLast(2) shouldBe typed.age.take(typed.nrow - 2)
+    }
+
+    @Test
+    fun `transpose row`() {
+        typed
+            .select { age and weight }[1]
+            .transpose()
+            .maxBy { it.value as Int? }
+            .name shouldBe "weight"
+        typed[2]
+            .transpose()
+            .dropNulls { value }
+            .name
+            .toList() shouldBe listOf("name", "age", "city")
+    }
+
+    @Test
+    fun xs() {
+        typed.xs("Charlie") shouldBe typed.filter { name == "Charlie" }.remove { name }
+        typed.xs("Charlie", 20).nrow shouldBe 1
+        typed.xs(20) { age }.nrow shouldBe 2
+        shouldThrow<java.lang.IllegalArgumentException> {
+            typed.xs(20) { age and weight }
+        }
+        shouldThrow<java.lang.IllegalArgumentException> {
+            typed.xs("Charlie", 20) { name }
+        }
+        shouldThrow<java.lang.IllegalArgumentException> {
+            typed.xs("Charlie", 20, "Moscow", null, 1)
+        }
+    }
+
+    @Test
+    fun `groupBy xs`() {
+        typed.groupBy { name }.xs("Charlie").concat() shouldBe typed.xs("Charlie")
+        typed
+            .groupBy { name }.xs("Moscow") { city }.concat()
+            .print()
+    }
+
+    @Test
+    fun getMissingColumn() {
+        val col = typed.getColumnsImpl(UnresolvedColumnsPolicy.Create) { "unknown"<Int>() }
+        col.size shouldBe 1
+        col[0].name shouldBe "unknown"
+        col[0].isMissingColumn() shouldBe true
+    }
+
+    @Test
+    fun getMissingColumn2() {
+        val col = typed.remove { city }.getColumnsImpl(UnresolvedColumnsPolicy.Create) { city }
+        col.size shouldBe 1
+        col[0].name shouldBe typed.city.name()
+        col[0].isMissingColumn() shouldBe true
+    }
+
+    @Test
+    fun `groupBy into accessor or kproperty`() {
+        val n by column<Int>()
+
+        data class Data(
+            @ColumnName("total") val count: Int,
+        )
+
+        typed.groupBy { name }.aggregate {
+            count() into n
+            count() into Data::count
+        } shouldBe
+            typed
+                .groupBy { name }.count(n.name())
+                .add("total") { "n"<Int>() }
+    }
+
+    @Test
+    fun `aggregate null row`() {
+        val aggregated = typed.groupBy { name }.aggregate {
+            (if (name.first().startsWith("A")) first() else null) into "agg"
+        }["agg"]
+
+        aggregated.kind shouldBe ColumnKind.Group
+        aggregated.size shouldBe 3
+        aggregated.count { it.isNA } shouldBe 2
+    }
+
+    @Test
+    fun takeWhile() {
+        typed.takeWhile { weight != null } shouldBe typed[0..1]
+        typed.takeWhile { true } shouldBe typed
+    }
+
+    @Test
+    fun dropWhile() {
+        typed.dropWhile { weight != null } shouldBe typed.drop(2)
+        typed.dropWhile { false } shouldBe typed
+    }
+
+    @Test
+    fun takeLast() {
+        typed.takeLast(2) shouldBe typed[5..6]
+        shouldThrow<IllegalArgumentException> {
+            typed.takeLast(-1)
+        }
+        typed.takeLast(20) shouldBe typed
+    }
+
+    @Test
+    fun dropLast() {
+        typed.dropLast(2) shouldBe typed[0..4]
+        shouldThrow<IllegalArgumentException> {
+            typed.dropLast(-1)
+        }
+        typed.dropLast(20) shouldBe typed.take(0)
+    }
+
+    @Test
+    fun drop() {
+        typed.drop(2) shouldBe typed[2..6]
+        shouldThrow<IllegalArgumentException> {
+            typed.drop(-1)
+        }
+        typed.drop(typed.nrow) shouldBe typed.filter { false }
+        typed.drop(20) shouldBe typed.filter { false }
+    }
+
+    @Test
+    fun take() {
+        typed.take(2) shouldBe typed[0..1]
+        shouldThrow<IllegalArgumentException> {
+            typed.take(-1)
+        }
+        typed.take(typed.nrow) shouldBe typed
+        typed.take(20) shouldBe typed
+    }
+
+    @Test
+    fun `select into accessor`() {
+        val newName by column<String>()
+        typed.select { name into newName and age }.columnNames() shouldBe listOf("newName", "age")
+    }
+
+    @Test
+    fun `api for creating GroupBy with empty groups which can be aggregated using statistics`() {
+        val df1 = dataFrameOf("a", "b")(1, "c")
+        val df2 = DataFrame.empty()
+        val groupBy = dataFrameOf(columnOf("group1", "group2") named "group", columnOf(df1, df2)).asGroupBy()
+
+        val exception = shouldThrow<IllegalStateException> {
+            groupBy.aggregate {
+                sum("a")
+            }
+        }
+
+        exception.message shouldBe "Column 'a' not found among []."
+
+        val groupBy1 = groupBy
+            .updateGroups { if (it.isEmpty()) DataFrame.empty(groupBy.groups.schema.value) else it }
+
+        val res = groupBy1.aggregate {
+            sum("a")
+        }
+
+        res["aggregated"].values() shouldBe listOf(1, 0)
+    }
+}
diff --git a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/testSets/person/DataFrameTreeTests.kt b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/testSets/person/DataFrameTreeTests.kt
new file mode 100644
index 000000000..619be9c67
--- /dev/null
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/testSets/person/DataFrameTreeTests.kt
@@ -0,0 +1,800 @@
+package org.jetbrains.kotlinx.dataframe.testSets.person
+
+import io.kotest.assertions.fail
+import io.kotest.assertions.throwables.shouldThrow
+import io.kotest.matchers.shouldBe
+import io.kotest.matchers.shouldNotBe
+import org.jetbrains.dataframe.impl.codeGen.CodeGenerator
+import org.jetbrains.dataframe.impl.codeGen.InterfaceGenerationMode
+import org.jetbrains.dataframe.impl.codeGen.generate
+import org.jetbrains.kotlinx.dataframe.AnyFrame
+import org.jetbrains.kotlinx.dataframe.AnyRow
+import org.jetbrains.kotlinx.dataframe.ColumnsContainer
+import org.jetbrains.kotlinx.dataframe.DataColumn
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.DataRow
+import org.jetbrains.kotlinx.dataframe.Selector
+import org.jetbrains.kotlinx.dataframe.annotations.DataSchema
+import org.jetbrains.kotlinx.dataframe.api.GroupBy
+import org.jetbrains.kotlinx.dataframe.api.GroupWithKey
+import org.jetbrains.kotlinx.dataframe.api.add
+import org.jetbrains.kotlinx.dataframe.api.addId
+import org.jetbrains.kotlinx.dataframe.api.after
+import org.jetbrains.kotlinx.dataframe.api.aggregate
+import org.jetbrains.kotlinx.dataframe.api.append
+import org.jetbrains.kotlinx.dataframe.api.asColumnGroup
+import org.jetbrains.kotlinx.dataframe.api.asDataFrame
+import org.jetbrains.kotlinx.dataframe.api.asFrame
+import org.jetbrains.kotlinx.dataframe.api.asGroupBy
+import org.jetbrains.kotlinx.dataframe.api.at
+import org.jetbrains.kotlinx.dataframe.api.by
+import org.jetbrains.kotlinx.dataframe.api.cast
+import org.jetbrains.kotlinx.dataframe.api.colsOf
+import org.jetbrains.kotlinx.dataframe.api.column
+import org.jetbrains.kotlinx.dataframe.api.columnGroup
+import org.jetbrains.kotlinx.dataframe.api.columnOf
+import org.jetbrains.kotlinx.dataframe.api.columnsCount
+import org.jetbrains.kotlinx.dataframe.api.concat
+import org.jetbrains.kotlinx.dataframe.api.convert
+import org.jetbrains.kotlinx.dataframe.api.count
+import org.jetbrains.kotlinx.dataframe.api.dataFrameOf
+import org.jetbrains.kotlinx.dataframe.api.distinct
+import org.jetbrains.kotlinx.dataframe.api.dropNulls
+import org.jetbrains.kotlinx.dataframe.api.duplicate
+import org.jetbrains.kotlinx.dataframe.api.duplicateRows
+import org.jetbrains.kotlinx.dataframe.api.emptyDataFrame
+import org.jetbrains.kotlinx.dataframe.api.explode
+import org.jetbrains.kotlinx.dataframe.api.expr
+import org.jetbrains.kotlinx.dataframe.api.filter
+import org.jetbrains.kotlinx.dataframe.api.forEach
+import org.jetbrains.kotlinx.dataframe.api.frameColumn
+import org.jetbrains.kotlinx.dataframe.api.getColumnGroup
+import org.jetbrains.kotlinx.dataframe.api.getColumnPath
+import org.jetbrains.kotlinx.dataframe.api.getColumnWithPath
+import org.jetbrains.kotlinx.dataframe.api.getColumns
+import org.jetbrains.kotlinx.dataframe.api.getValue
+import org.jetbrains.kotlinx.dataframe.api.group
+import org.jetbrains.kotlinx.dataframe.api.groupBy
+import org.jetbrains.kotlinx.dataframe.api.implode
+import org.jetbrains.kotlinx.dataframe.api.indices
+import org.jetbrains.kotlinx.dataframe.api.insert
+import org.jetbrains.kotlinx.dataframe.api.into
+import org.jetbrains.kotlinx.dataframe.api.intoRows
+import org.jetbrains.kotlinx.dataframe.api.inward
+import org.jetbrains.kotlinx.dataframe.api.isColumnGroup
+import org.jetbrains.kotlinx.dataframe.api.isEmpty
+import org.jetbrains.kotlinx.dataframe.api.isFrameColumn
+import org.jetbrains.kotlinx.dataframe.api.join
+import org.jetbrains.kotlinx.dataframe.api.last
+import org.jetbrains.kotlinx.dataframe.api.map
+import org.jetbrains.kotlinx.dataframe.api.max
+import org.jetbrains.kotlinx.dataframe.api.maxBy
+import org.jetbrains.kotlinx.dataframe.api.median
+import org.jetbrains.kotlinx.dataframe.api.minus
+import org.jetbrains.kotlinx.dataframe.api.move
+import org.jetbrains.kotlinx.dataframe.api.moveTo
+import org.jetbrains.kotlinx.dataframe.api.moveToLeft
+import org.jetbrains.kotlinx.dataframe.api.moveToRight
+import org.jetbrains.kotlinx.dataframe.api.pathOf
+import org.jetbrains.kotlinx.dataframe.api.perRowCol
+import org.jetbrains.kotlinx.dataframe.api.pivot
+import org.jetbrains.kotlinx.dataframe.api.remove
+import org.jetbrains.kotlinx.dataframe.api.rename
+import org.jetbrains.kotlinx.dataframe.api.rows
+import org.jetbrains.kotlinx.dataframe.api.select
+import org.jetbrains.kotlinx.dataframe.api.single
+import org.jetbrains.kotlinx.dataframe.api.sortBy
+import org.jetbrains.kotlinx.dataframe.api.split
+import org.jetbrains.kotlinx.dataframe.api.sumOf
+import org.jetbrains.kotlinx.dataframe.api.toColumnAccessor
+import org.jetbrains.kotlinx.dataframe.api.toDataFrame
+import org.jetbrains.kotlinx.dataframe.api.toTop
+import org.jetbrains.kotlinx.dataframe.api.under
+import org.jetbrains.kotlinx.dataframe.api.ungroup
+import org.jetbrains.kotlinx.dataframe.api.update
+import org.jetbrains.kotlinx.dataframe.api.values
+import org.jetbrains.kotlinx.dataframe.api.with
+import org.jetbrains.kotlinx.dataframe.api.withNull
+import org.jetbrains.kotlinx.dataframe.api.xs
+import org.jetbrains.kotlinx.dataframe.columns.ColumnGroup
+import org.jetbrains.kotlinx.dataframe.columns.ColumnKind
+import org.jetbrains.kotlinx.dataframe.columns.FrameColumn
+import org.jetbrains.kotlinx.dataframe.columns.depth
+import org.jetbrains.kotlinx.dataframe.hasNulls
+import org.junit.Test
+import kotlin.reflect.typeOf
+
+class DataFrameTreeTests : BaseTest() {
+
+    @DataSchema
+    interface NameAndCity {
+        val name: String
+        val city: String?
+    }
+
+    @DataSchema
+    interface GroupedPerson {
+        val nameAndCity: DataRow<NameAndCity>
+        val age: Int
+        val weight: Int?
+    }
+
+    val df2 = df.move { name and city }.under("nameAndCity")
+    val typed2 = df2.cast<GroupedPerson>()
+
+    val nameAndCity by columnGroup()
+    val nameInGroup = nameAndCity.column<String>("name")
+
+    @Test
+    fun create() {
+        val nameAndCity by columnOf(typed.name, typed.city)
+        val df3 = dataFrameOf(nameAndCity, typed.age, typed.weight)
+        df3 shouldBe df2
+    }
+
+    @Test
+    fun createFrameColumn() {
+        val rowsColumn by columnOf(typed[0..3], typed[4..5], typed[6..6])
+        val df = dataFrameOf(rowsColumn).asGroupBy { rowsColumn }
+        val res = df.concat()
+        res shouldBe typed
+    }
+
+    @Test
+    fun createFrameColumn2() {
+        val id by column(typed.indices())
+        val groups by id.map { typed[it..it] }
+        val df = dataFrameOf(id, groups)
+        df.rowsCount() shouldBe typed.rowsCount()
+        df.forEach {
+            val rowId = it[id]
+            groups() shouldBe typed[rowId..rowId]
+        }
+    }
+
+    @Test
+    fun `select atAnyDepth under group`() {
+        df2.select { nameAndCity.colsAtAnyDepth().colsOf<String>() } shouldBe typed2.select { nameAndCity.name }
+        df2.select { nameAndCity.colsAtAnyDepth().colsOf<String?>() } shouldBe
+            typed2.select { nameAndCity.name and nameAndCity.city }
+    }
+
+    @Test
+    fun `selects`() {
+        df2.select { nameAndCity.cols() } shouldBe typed2.nameAndCity.select { all() }
+        df2.select { nameAndCity.cols { !it.hasNulls() } } shouldBe typed2.select { nameAndCity.name }
+        df2.select { nameAndCity.cols(0..1) } shouldBe typed2.nameAndCity.select { all() }
+        df2.select { nameAndCity.col(1) } shouldBe typed2.select { nameAndCity.city }
+        df2.select { nameAndCity["city"] } shouldBe typed2.select { nameAndCity.city }
+        df2.select { nameAndCity.cols("city", "name") } shouldBe typed2.select { nameAndCity.city and nameAndCity.name }
+        df2.select { nameAndCity.cols(name, city) } shouldBe typed2.select { nameAndCity.allCols() }
+        df2.select { nameAndCity[name] } shouldBe typed2.nameAndCity.select { name }
+        df2.select { nameAndCity.cols().drop(1) } shouldBe typed2.nameAndCity.select { city }
+
+        typed2.select { nameAndCity.cols() } shouldBe typed2.nameAndCity.select { all() }
+        typed2.select { nameAndCity.cols { !it.hasNulls() } } shouldBe typed2.select { nameAndCity.name }
+        typed2.select { nameAndCity.cols(0..1) } shouldBe typed2.nameAndCity.select { all() }
+        typed2.select { nameAndCity.col(1) } shouldBe typed2.select { nameAndCity.city }
+        typed2.select { nameAndCity["city"] } shouldBe typed2.select { nameAndCity.city }
+        typed2.select { nameAndCity.cols("city", "name") } shouldBe
+            typed2.select { nameAndCity.city and nameAndCity.name }
+        typed2.select { nameAndCity.cols(name, city) } shouldBe typed2.select { nameAndCity.allCols() }
+        typed2.select { nameAndCity[name] } shouldBe typed2.nameAndCity.select { name }
+        typed2.select { nameAndCity.cols().drop(1) } shouldBe typed2.nameAndCity.select { city }
+
+        df2.select { col(1) } shouldBe typed2.select { age }
+        df2.select { nameInGroup } shouldBe typed2.nameAndCity.select { name }
+
+        df2[nameInGroup] shouldBe typed2.nameAndCity.name
+    }
+
+    @Test
+    fun getColumnPath() {
+        typed2.getColumnPath { nameAndCity["city"] }.size shouldBe 2
+        typed2.getColumnPath { nameAndCity.col(1) }.size shouldBe 2
+    }
+
+    @Test
+    fun `group indexing`() {
+        df2[nameAndCity][city] shouldBe typed.city
+        typed2.nameAndCity.city shouldBe typed.city
+        df2["nameAndCity"]["city"] shouldBe typed.city
+    }
+
+    @Test
+    fun `convert column group`() {
+        val expected = typed.select { city.rename("nameAndCity") and age and weight }
+
+        df2.convert { nameAndCity }.with { it[city] } shouldBe expected
+        df2.convert { nameAndCity }.with { this[nameAndCity][city] } shouldBe expected
+        typed2.convert { nameAndCity }.with { nameAndCity.city } shouldBe expected
+        typed2.convert { nameAndCity }.with { it.city } shouldBe expected
+    }
+
+    @Test
+    fun `slice`() {
+        val expected = typed[0..2].name
+        val actual = typed2[0..2].nameAndCity.name
+        actual shouldBe expected
+    }
+
+    @Test
+    fun `filter`() {
+        val expected = typed.filter { city == null }.select { weight }
+        typed2.filter { nameAndCity.city == null }.select { weight } shouldBe expected
+        df2.filter { it[nameAndCity][city] == null }.select { weight } shouldBe expected
+    }
+
+    @Test
+    fun `select`() {
+        val expected = typed.select { name and age }
+        typed2.select { nameAndCity.name and age } shouldBe expected
+        df2.select { it[nameAndCity][name] and age } shouldBe expected
+    }
+
+    @Test
+    fun `sort`() {
+        val expected = typed.sortBy { name and age }.moveTo(1) { city }
+        typed2.sortBy { nameAndCity.name and age }.ungroup { nameAndCity } shouldBe expected
+    }
+
+    @Test
+    fun `move`() {
+        val actual = typed2.move { nameAndCity.name }.into("name")
+        actual.columnNames() shouldBe listOf("nameAndCity", "name", "age", "weight")
+        actual.getColumnGroup("nameAndCity").columnNames() shouldBe listOf("city")
+    }
+
+    @Test
+    fun `groupBy`() {
+        val expected = typed.groupBy { name }.max { age }
+        typed2.groupBy { nameAndCity.name }.max { age } shouldBe expected
+    }
+
+    @Test
+    fun `distinct`() {
+        val duplicated = typed2.concat(typed2)
+        duplicated.rowsCount() shouldBe typed2.rowsCount() * 2
+        val dist = duplicated.nameAndCity.distinct()
+        dist shouldBe typed2.nameAndCity.distinct()
+        dist.rowsCount() shouldBe typed2.rowsCount() - 1
+    }
+
+    @Test
+    fun `select atAnyDepth`() {
+        val cols = typed2.select { colsAtAnyDepth { it.hasNulls } }
+        cols shouldBe typed2.select { nameAndCity.city and weight }
+    }
+
+    @Test
+    fun `get child column by accessor`() {
+        val cityCol by column<String?>("city")
+        val selected = typed2.getColumnWithPath {
+            val g = nameAndCity
+            val c = g.get(cityCol)
+            c
+        }
+        selected.path shouldBe pathOf("nameAndCity", "city")
+    }
+
+    @Test
+    fun splitRows() {
+        val selected = typed2.select { nameAndCity }
+        val nested = selected.implode(dropNA = false) { nameAndCity.city }
+        val mergedCity = column<List<String?>>("city")
+        val res = nested.split { nameAndCity[mergedCity] }.intoRows()
+        val expected = selected.sortBy { nameAndCity.name }
+        val actual = res.sortBy { nameAndCity.name }
+        actual shouldBe expected
+    }
+
+    @Test
+    fun pivot() {
+        val modified = df.append("Alice", 55, "Moscow", 100)
+        val df2 = modified.move { name and city }.under("nameAndCity")
+        val typed2 = df2.cast<GroupedPerson>()
+
+        fun <T, G, R> GroupBy<T, G>.map(body: Selector<GroupWithKey<T, G>, R>): List<R> =
+            keys.rows().mapIndexedNotNull { index, row ->
+                val group = groups[index]
+                val g = GroupWithKey(row, group)
+                body(g, g)
+            }
+
+        val expected = modified.cast<Person>()
+            .groupBy { name and city }.map {
+                val value = if (key.city == "Moscow") {
+                    group.age.toList()
+                } else {
+                    group.age[0]
+                }
+                (key.name to key.city.toString()) to value
+            }
+            .plus("Bob" to "Moscow" to emptyList<Int>())
+            .toMap()
+
+        fun <T> DataFrame<T>.check() {
+            columnsCount() shouldBe 2
+            val cities = getColumnGroup("nameAndCity").getColumnGroup("city")
+            cities.columnsCount() shouldBe typed2.nameAndCity.city.countDistinct()
+            this[name] shouldBe typed.name.distinct()
+            val data = cities.columns()
+            data.forEach {
+                if (it.name() == "Moscow") {
+                    it.type() shouldBe typeOf<List<Int>>()
+                } else {
+                    it.type() shouldBe typeOf<Int?>()
+                }
+            }
+
+            val actual = data.flatMap { col ->
+                val city = col.name()
+                rows().map { (it[name] to city) to col[it.index()] }.filter { it.second != null }
+            }.toMap()
+            actual shouldBe expected
+        }
+
+        typed2.pivot { nameAndCity.city }.groupBy { nameAndCity.name }.values { age }.check()
+        df2.pivot(nameAndCity[city]).groupBy { nameAndCity[name] }.values(age).check()
+        df2.pivot { it[GroupedPerson::nameAndCity][NameAndCity::city] }.groupBy {
+            it[GroupedPerson::nameAndCity][NameAndCity::name]
+        }.values(GroupedPerson::age).check()
+        df2.pivot { it["nameAndCity"]["city"] }.groupBy { it["nameAndCity"]["name"] }.values("age").check()
+    }
+
+    @Test
+    fun `pivot grouped column`() {
+        val grouped = typed.group { age and weight }.into("info")
+        val pivoted = grouped.pivot { city }.groupBy { name }.values("info")
+        pivoted.columnsCount() shouldBe 2
+
+        val expected = typed
+            .rows()
+            .groupBy { it.name to (it.city ?: "null") }
+            .mapValues { it.value.map { it.age to it.weight } }
+        val dataCols = pivoted.getColumns { col(1).asColumnGroup().allCols() }
+
+        dataCols.forEach { (it.isColumnGroup() || it.isFrameColumn()) shouldBe true }
+
+        val names = pivoted.name
+        dataCols.forEach { col ->
+            val city = col.name()
+            pivoted.indices().forEach { row ->
+                val name = names[row]
+                val value = col[row]
+                val expValues = expected[name to city]
+                when {
+                    expValues == null -> when (value) {
+                        null -> {
+                        }
+
+                        is AnyRow -> value.isEmpty() shouldBe true
+
+                        is AnyFrame -> value.columnsCount() shouldBe 0
+                    }
+
+                    expValues.size == 1 -> {
+                        value shouldNotBe null
+                        val single =
+                            if (value is AnyRow) {
+                                value
+                            } else if (value is AnyFrame) {
+                                value[0]
+                            } else {
+                                fail("invalid value type")
+                            }
+                        single.columnsCount() shouldBe 2
+                        single.getValue<Int>("age") to single.getValue<Int?>("weight") shouldBe expValues[0]
+                    }
+
+                    else -> {
+                        val df = value as? AnyFrame
+                        df shouldNotBe null
+                        df!!.rows()
+                            .map { it["age"] as Int to it["weight"] as Int? }
+                            .sortedBy { it.first } shouldBe expValues.sortedBy { it.first }
+                    }
+                }
+            }
+        }
+    }
+
+    @Test
+    fun splitCols() {
+        val split = typed2.split { nameAndCity.name }.by { it.toCharArray().toList() }.inward { "char$it" }
+        split.columnNames() shouldBe typed2.columnNames()
+        split.rowsCount() shouldBe typed2.rowsCount()
+        split.nameAndCity.columnNames() shouldBe typed2.nameAndCity.columnNames()
+        val nameGroup = split.nameAndCity.name.asColumnGroup()
+        nameGroup.name() shouldBe "name"
+        nameGroup.columnsCount() shouldBe
+            typed2.nameAndCity.name
+                .map { it.length }
+                .max()
+        nameGroup.columnNames() shouldBe (1..nameGroup.columnsCount()).map { "char$it" }
+    }
+
+    @Test
+    fun `split into rows`() {
+        val split = typed2.split { nameAndCity.name }.by { it.toCharArray().toList() }.intoRows()
+        val merged = split.implode { nameAndCity.name }
+        val joined = merged.convert { nameAndCity.name }.cast<List<Char>>().with { it.joinToString("") }
+        joined shouldBe typed2
+    }
+
+    @Test
+    fun `all except`() {
+        val info by columnGroup()
+        val moved = typed.group { allExcept(name) }.into(info)
+        val actual = moved.select { allExcept(info) }
+        actual shouldBe typed.select { name }
+    }
+
+    @Test
+    fun `move and group`() {
+        val info by columnGroup()
+        val moved = typed.group { allExcept(name) }.into(info)
+        val grouped = moved.groupBy { allExcept(info) }.toDataFrame()
+        grouped.rowsCount() shouldBe typed.name.countDistinct()
+    }
+
+    @Test
+    fun `merge rows into table`() {
+        val info by columnGroup()
+        val moved = typed.group { allExcept(name) }.into(info)
+        val merged = moved.implode { info }
+        val grouped = typed.groupBy { name }.updateGroups { remove { name } }
+        val expected = grouped.toDataFrame().rename(grouped.groups).into(info)
+        merged shouldBe expected
+    }
+
+    @Test
+    fun `update grouped column to table`() {
+        val info by columnGroup()
+        val grouped = typed.group { age and weight }.into(info)
+        val updated = grouped.convert(info).perRowCol { row, column -> column.asColumnGroup().asDataFrame() }
+        val col = updated[info.name()]
+        col.kind() shouldBe ColumnKind.Frame
+        val table = col as FrameColumn<*>
+        table.schema.value.columns
+            .map { it.key }
+            .sorted() shouldBe
+            typed
+                .select { age and weight }
+                .columnNames()
+                .sorted()
+    }
+
+    @Test
+    fun extensionPropertiesTest() {
+        val code = CodeGenerator.create()
+            .generate<GroupedPerson>(
+                interfaceMode = InterfaceGenerationMode.None,
+                extensionProperties = true,
+            ).declarations
+        val columnsContainer = ColumnsContainer::class.qualifiedName
+        val dataFrameRowBase = DataRow::class.qualifiedName
+        val dataFrameRow = DataRow::class.qualifiedName
+        val className = GroupedPerson::class.qualifiedName
+        val shortName = GroupedPerson::class.simpleName!!
+        val nameAndCity = NameAndCity::class.qualifiedName
+        val groupedColumn = ColumnGroup::class.qualifiedName
+        val columnData = DataColumn::class.qualifiedName
+        val expected =
+            """
+            val $columnsContainer<$className>.age: $columnData<kotlin.Int> @JvmName("${shortName}_age") get() = this["age"] as $columnData<kotlin.Int>
+            val $dataFrameRowBase<$className>.age: kotlin.Int @JvmName("${shortName}_age") get() = this["age"] as kotlin.Int
+            val $columnsContainer<$className?>.age: $columnData<kotlin.Int?> @JvmName("Nullable${shortName}_age") get() = this["age"] as $columnData<kotlin.Int?>
+            val $dataFrameRowBase<$className?>.age: kotlin.Int? @JvmName("Nullable${shortName}_age") get() = this["age"] as kotlin.Int?
+            val $columnsContainer<$className>.nameAndCity: $groupedColumn<$nameAndCity> @JvmName("${shortName}_nameAndCity") get() = this["nameAndCity"] as $groupedColumn<$nameAndCity>
+            val $dataFrameRowBase<$className>.nameAndCity: $dataFrameRow<$nameAndCity> @JvmName("${shortName}_nameAndCity") get() = this["nameAndCity"] as $dataFrameRow<$nameAndCity>
+            val $columnsContainer<$className?>.nameAndCity: $groupedColumn<$nameAndCity?> @JvmName("Nullable${shortName}_nameAndCity") get() = this["nameAndCity"] as $groupedColumn<$nameAndCity?>
+            val $dataFrameRowBase<$className?>.nameAndCity: $dataFrameRow<$nameAndCity?> @JvmName("Nullable${shortName}_nameAndCity") get() = this["nameAndCity"] as $dataFrameRow<$nameAndCity?>
+            val $columnsContainer<$className>.weight: $columnData<kotlin.Int?> @JvmName("${shortName}_weight") get() = this["weight"] as $columnData<kotlin.Int?>
+            val $dataFrameRowBase<$className>.weight: kotlin.Int? @JvmName("${shortName}_weight") get() = this["weight"] as kotlin.Int?
+            val $columnsContainer<$className?>.weight: $columnData<kotlin.Int?> @JvmName("Nullable${shortName}_weight") get() = this["weight"] as $columnData<kotlin.Int?>
+            val $dataFrameRowBase<$className?>.weight: kotlin.Int? @JvmName("Nullable${shortName}_weight") get() = this["weight"] as kotlin.Int?
+            """.trimIndent()
+        code shouldBe expected
+    }
+
+    @Test
+    fun parentColumnTest() {
+        val res = typed2.move { colsAtAnyDepth { it.depth > 0 } }.toTop { it.parentName + "-" + it.name }
+        res.columnsCount() shouldBe 4
+        res.columnNames() shouldBe listOf("nameAndCity-name", "nameAndCity-city", "age", "weight")
+    }
+
+    @Test
+    fun `group cols`() {
+        val joined = typed2.move { colsAtAnyDepth { !it.isColumnGroup() } }.into { pathOf(it.path.joinToString(".")) }
+        val grouped = joined.group { nameContains(".") }.into { it.name().substringBefore(".") }
+        val expected = typed2.rename { nameAndCity.allCols() }.into { it.path.joinToString(".") }
+        grouped shouldBe expected
+    }
+
+    @Test
+    fun `group into column`() {
+        val grouped = typed2.group { age }.into { nameAndCity }
+        grouped.nameAndCity.columnsCount() shouldBe 3
+        grouped.columnsCount() shouldBe 2
+    }
+
+    @Test
+    fun rename() {
+        val res = typed2.rename { nameAndCity.allCols() }.into { it.name().capitalize() }
+        res.nameAndCity.columnNames() shouldBe typed2.nameAndCity.columnNames().map { it.capitalize() }
+    }
+
+    @Test
+    fun moveAfter() {
+        val moved = typed2.move { age }.after { nameAndCity.name }
+        moved.columnsCount() shouldBe 2
+        moved.nameAndCity.columnsCount() shouldBe 3
+        moved.nameAndCity.select { all() } shouldBe dataFrameOf(
+            typed2.nameAndCity.name,
+            typed2.age,
+            typed2.nameAndCity.city,
+        )
+    }
+
+    @Test
+    fun moveAfter2() {
+        val moved = typed2.move { nameAndCity.name }.after { age }
+        moved.columnsCount() shouldBe 4
+        moved.nameAndCity.columnsCount() shouldBe 1
+        moved.remove { nameAndCity } shouldBe typed2.select { age and nameAndCity.name and weight }
+    }
+
+    @Test
+    fun splitFrameColumnsIntoRows() {
+        val grouped = typed.groupBy { city }
+        val groupCol = grouped.groups.name()
+        val plain = grouped.toDataFrame()
+        val res = plain
+            .split(grouped.groups).intoRows()
+            .remove { it[groupCol]["city"] }
+            .ungroup(groupCol)
+            .sortBy { name and age }
+        res shouldBe typed.sortBy { name and age }.moveToLeft { city }
+    }
+
+    @Test
+    fun splitFrameColumnIntoColumns() {
+        val grouped = typed.groupBy { city }
+        val groupCol = grouped.groups.name()
+        val plain = grouped.toDataFrame()
+        val res = plain
+            .split(grouped.groups).intoRows()
+            .remove { it[groupCol]["city"] }
+            .ungroup(groupCol)
+            .sortBy { name and age }
+        res shouldBe typed.sortBy { name and age }.moveToLeft { city }
+    }
+
+    @Test
+    fun explodeFrameColumnWithNulls() {
+        val grouped = typed.groupBy { city }
+        val groupCol = grouped.groups.toColumnAccessor()
+        val plain = grouped.toDataFrame()
+            .update { groupCol }.at(1).withNull()
+            .update { groupCol }.at(2).with { emptyDataFrame() }
+            .update { groupCol }.at(3).with { it.filter { false } }
+        val res = plain.explode(dropEmpty = false) { groupCol }
+        val expected = plain[groupCol.name()].sumOf { Math.max((it as AnyFrame?)?.rowsCount() ?: 0, 1) }
+        res.rowsCount() shouldBe expected
+    }
+
+    @Test
+    fun `join with left path`() {
+        val joined = (typed2 - { weight }).join(typed - { city }) { nameAndCity.name.match(right.name) and age }
+        joined shouldBe typed2
+    }
+
+    @Test
+    fun `join with right path`() {
+        val joined = (typed - { city }).join(typed2 - { weight }) { name.match(right.nameAndCity.name) and age }
+        val expected = typed.moveToRight { city }.move { city }.under("nameAndCity")
+        joined shouldBe expected
+    }
+
+    @Test
+    fun `join by map column`() {
+        val nameAndAge by columnGroup()
+        val cityFirst by nameAndAge.column<Char?>()
+        val grouped = typed.group { name and age }.into(nameAndAge).add(cityFirst) { city?.get(0) }
+        grouped[nameAndAge].columnsCount() shouldBe 3
+
+        val left = grouped - { weight }
+        val right = grouped - { city }
+        val joined = left.join(right) { nameAndAge }
+        joined shouldBe grouped
+    }
+
+    @Test
+    fun `join by frame column`() {
+        val left = typed.groupBy { name }.updateGroups { it.remove { name and city } }
+        val right =
+            typed.update { name }.with { it.reversed() }
+                .groupBy { name }.updateGroups { it.remove { name and city } }
+        val groupCol = left.groups.toColumnAccessor()
+        val joined = left.toDataFrame().join(right.toDataFrame()) { groupCol }
+        joined.columnsCount() shouldBe 3
+        val name1 by column<String>()
+        joined.columnNames() shouldBe listOf(typed.name.name(), groupCol.name(), name1.name())
+        joined[groupCol].kind() shouldBe ColumnKind.Frame
+        joined.select { cols(0, 1) } shouldBe left.toDataFrame()
+        joined.select { cols(2, 1) }.rename(name1).into(typed.name) shouldBe right.toDataFrame()
+        joined.name shouldBe left.keys.name
+        joined.forEach { it[name1] shouldBe it.name.reversed() }
+    }
+
+    @Test
+    fun `add frame column`() {
+        val frameCol by frameColumn()
+        val added = typed2.add(frameCol) { nameAndCity.duplicate(3) }
+        added[frameCol].kind() shouldBe ColumnKind.Frame
+        added[frameCol].forEach { it.rowsCount() shouldBe 3 }
+    }
+
+    @Test
+    fun `insert column`() {
+        val colName = "reversed"
+
+        fun DataFrame<GroupedPerson>.check() {
+            nameAndCity.columnsCount() shouldBe 3
+            nameAndCity.columnNames() shouldBe listOf(
+                typed2.nameAndCity.name.name(),
+                colName,
+                typed2.nameAndCity.city.name(),
+            )
+        }
+
+        typed2.insert(colName) { nameAndCity.name.reversed() }.after { nameAndCity.name }.check()
+    }
+
+    @Test
+    fun append() {
+        val res = typed2.append(listOf("Bill", "San Francisco"), null, 66)
+        res.rowsCount() shouldBe typed2.rowsCount() + 1
+        res.nameAndCity.last().values() shouldBe listOf("Bill", "San Francisco")
+        res.age.hasNulls() shouldBe true
+    }
+
+    @Test
+    fun `append nulls`() {
+        val res = typed2.append(null, null, null)
+        res.rowsCount() shouldBe typed2.rowsCount() + 1
+        res.nameAndCity.last().values() shouldBe listOf(null, null)
+        res.age.hasNulls() shouldBe true
+        res.nameAndCity.name.hasNulls() shouldBe true
+    }
+
+    @Test
+    fun `create data frame from map column`() {
+        val df = dataFrameOf(typed.name, typed2.nameAndCity)
+        df.rowsCount() shouldBe typed.rowsCount()
+    }
+
+    @Test
+    fun `column group properties`() {
+        typed2.nameAndCity.name() shouldBe "nameAndCity"
+        val renamed = typed2.nameAndCity.rename("newName")
+        renamed.name() shouldBe "newName"
+        renamed.select { name } shouldBe typed2.select { nameAndCity.name }
+        renamed.filter { name.startsWith("A") }.rowsCount() shouldBe typed.count { name.startsWith("A") }
+    }
+
+    @Test
+    fun `distinct at column group`() {
+        typed2.nameAndCity.distinct().filter { name.startsWith("A") }.columns() shouldBe
+            typed
+                .select { name and city }
+                .distinct()
+                .filter { name.startsWith("A") }
+                .columns()
+    }
+
+    @Test
+    fun `check column path`() {
+        typed2.getColumnPath { nameAndCity.name }.size shouldBe 2
+    }
+
+    @Test
+    fun `filter not null without arguments`() {
+        typed2.dropNulls() shouldBe typed.dropNulls { weight }.group { name and city }.into("nameAndCity")
+    }
+
+    @Test
+    fun `select group`() {
+        val groupCol = typed2[nameAndCity]
+        typed2.select { groupCol and age }.columnNames() shouldBe listOf("nameAndCity", "age")
+    }
+
+    @Test
+    fun `select columns range`() {
+        val added = typed2.move { age }.after { nameAndCity.name }
+        val expected = typed2.select { nameAndCity.name and age and nameAndCity.city }
+
+        added.select { nameAndCity.name..nameAndCity.city } shouldBe expected
+
+        shouldThrow<IllegalArgumentException> {
+            added.select { nameAndCity.name..weight }
+        }
+
+        shouldThrow<IllegalArgumentException> {
+            added.select { weight..nameAndCity.name }
+        }
+
+        shouldThrow<IllegalArgumentException> {
+            added.select { nameAndCity.city..nameAndCity.name }
+        }
+
+        added.select { nameAndCity.select { name..city } } shouldBe expected
+    }
+
+    @Test
+    fun groupByAggregateSingleColumn() {
+        val agg = typed2.groupBy { age }.aggregate { nameAndCity into "nameAndCity" }
+        agg["nameAndCity"].kind() shouldBe ColumnKind.Frame
+        typed2.groupBy { age }.aggregate { nameAndCity.asDataFrame() into "nameAndCity" } shouldBe agg
+        typed2.groupBy { age }.values { nameAndCity } shouldBe agg
+    }
+
+    @Test
+    fun `xs nested columns`() {
+        typed2.xs("Bob", "Tokyo").rowsCount() shouldBe 1
+    }
+
+    @Test
+    fun `duplicate dataframe`() {
+        typed2.duplicate(2) shouldBe columnOf(typed2, typed2)
+    }
+
+    @Test
+    fun `duplicate row`() {
+        typed2[2].duplicate(2) shouldBe typed2[2, 2]
+    }
+
+    @Test
+    fun `duplicate selected rows`() {
+        typed2.duplicateRows(2) { nameAndCity.name == "Alice" } shouldBe typed2[0, 0, 1, 2, 3, 4, 5, 5, 6]
+    }
+
+    @Test
+    fun `duplicate all rows`() {
+        typed2.duplicateRows(2) shouldBe typed2.addId("id").let {
+            it.concat(it).sortBy("id").remove("id")
+        }
+    }
+
+    @Test
+    fun `select column group`() {
+        typed2.aggregate {
+            nameAndCity()[2..3].name.distinct().single() into "name"
+        }["name"] shouldBe "Charlie"
+    }
+
+    @Test
+    fun `select frame column`() {
+        val group by frameColumn<GroupedPerson>()
+
+        typed2
+            .groupBy { expr { age > 30 } into "isOld" }.into(group)
+            .aggregate {
+                group().maxBy { rowsCount() }.weight.median() into "m"
+            }["m"] shouldBe 61
+    }
+
+    @Test
+    fun `column group as DataFrame`() {
+        val a: DataFrame<NameAndCity> = typed2["nameAndCity"].cast<DataRow<NameAndCity>>().asDataFrame()
+        val b: DataFrame<NameAndCity> = typed2[nameAndCity].cast<NameAndCity>().asDataFrame()
+    }
+
+    @Test
+    fun `convert ColumnGroup as Frame`() {
+        val df = typed2.convert { nameAndCity }.asFrame { it.remove { city } }
+        df.nameAndCity.columns() shouldBe typed2.nameAndCity.remove { city }.columns()
+    }
+}
diff --git a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/testSets/person/DataRowTests.kt b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/testSets/person/DataRowTests.kt
new file mode 100644
index 000000000..e28dcd394
--- /dev/null
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/testSets/person/DataRowTests.kt
@@ -0,0 +1,121 @@
+package org.jetbrains.kotlinx.dataframe.testSets.person
+
+import io.kotest.matchers.shouldBe
+import org.jetbrains.kotlinx.dataframe.api.by
+import org.jetbrains.kotlinx.dataframe.api.columnNames
+import org.jetbrains.kotlinx.dataframe.api.convert
+import org.jetbrains.kotlinx.dataframe.api.dataFrameOf
+import org.jetbrains.kotlinx.dataframe.api.diffOrNull
+import org.jetbrains.kotlinx.dataframe.api.drop
+import org.jetbrains.kotlinx.dataframe.api.dropLast
+import org.jetbrains.kotlinx.dataframe.api.first
+import org.jetbrains.kotlinx.dataframe.api.intoList
+import org.jetbrains.kotlinx.dataframe.api.mapToColumn
+import org.jetbrains.kotlinx.dataframe.api.merge
+import org.jetbrains.kotlinx.dataframe.api.name
+import org.jetbrains.kotlinx.dataframe.api.namedValues
+import org.jetbrains.kotlinx.dataframe.api.namedValuesOf
+import org.jetbrains.kotlinx.dataframe.api.next
+import org.jetbrains.kotlinx.dataframe.api.prev
+import org.jetbrains.kotlinx.dataframe.api.relative
+import org.jetbrains.kotlinx.dataframe.api.rowMean
+import org.jetbrains.kotlinx.dataframe.api.rowStd
+import org.jetbrains.kotlinx.dataframe.api.rowSum
+import org.jetbrains.kotlinx.dataframe.api.toDouble
+import org.jetbrains.kotlinx.dataframe.api.transposeTo
+import org.jetbrains.kotlinx.dataframe.api.update
+import org.jetbrains.kotlinx.dataframe.api.value
+import org.jetbrains.kotlinx.dataframe.api.valuesOf
+import org.jetbrains.kotlinx.dataframe.api.with
+import org.junit.Test
+import kotlin.math.sqrt
+
+class DataRowTests : BaseTest() {
+
+    @Test
+    fun prevNext() {
+        typed.update { age }.with { prev()?.age }
+            .age
+            .drop(1) shouldBe typed.age.dropLast(1)
+        typed.update { age }.with { next()?.age }
+            .age
+            .dropLast(1) shouldBe typed.age.drop(1)
+    }
+
+    @Test
+    fun diff() {
+        typed.update { age }.with { diffOrNull { age } }
+            .age
+            .drop(1)
+            .values() shouldBe typed.age.values().zipWithNext { curr, next -> next - curr }
+    }
+
+    @Test
+    fun mean() {
+        typed.mapToColumn("mean") { rowMean() }.values() shouldBe
+            typed.age
+                .values()
+                .zip(typed.weight.values()) { a, b -> if (b != null) (a + b) / 2.0 else a }
+    }
+
+    @Test
+    fun std() {
+        typed.mapToColumn("std") { rowStd(skipNA = true, ddof = 0) }.values() shouldBe typed.age
+            .values()
+            .zip(typed.weight.values()) { a, b ->
+                if (b == null) {
+                    .0
+                } else {
+                    val mean = (a + b) / 2.0
+                    sqrt(((a - mean) * (a - mean) + (b - mean) * (b - mean)) / 2)
+                }
+            }
+    }
+
+    @Test
+    fun sum() {
+        typed
+            .convert { weight }.toDouble()
+            .mapToColumn("sum") { rowSum() }
+            .values() shouldBe
+            typed.age.values().zip(typed.weight.values()) { a, b -> a + (b ?: 0).toDouble() }
+    }
+
+    @Test
+    fun namedValuesOf() {
+        typed.mapToColumn("vals") {
+            namedValuesOf<Int>().map { it.value }
+        }.values() shouldBe typed.merge { age and weight }.by { it.filterNotNull() }.intoList()
+    }
+
+    @Test
+    fun valuesOf() {
+        typed.mapToColumn("vals") {
+            valuesOf<String>()
+        }.values() shouldBe typed.merge { name and city }.by { it.filterNotNull() }.intoList()
+    }
+
+    @Test
+    fun namedValuesFilter() {
+        typed.mapToColumn("vals") {
+            namedValues().firstOrNull { it.value == null }?.name
+        } shouldBe typed.mapToColumn("vals") {
+            val firstNullIndex = values().indexOfFirst { it == null }
+            if (firstNullIndex == -1) null else columnNames()[firstNullIndex]
+        }
+    }
+
+    @Test
+    fun transposeTo() {
+        val df = dataFrameOf("a", "b")(1, 2).first().transposeTo<Int>()
+        df.name.toList() shouldBe listOf("a", "b")
+        df.value.toList() shouldBe listOf(1, 2)
+    }
+
+    @Test
+    fun relativeTest() {
+        typed[1].relative(0..0) shouldBe typed[1..1]
+        typed[1].relative(-2..2) shouldBe typed[0..3]
+        typed[1].relative(listOf(2, -1, -3, 0)) shouldBe typed[3, 0, 1]
+    }
+}
diff --git a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/testSets/person/FormattingTests.kt b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/testSets/person/FormattingTests.kt
new file mode 100644
index 000000000..72409ff56
--- /dev/null
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/testSets/person/FormattingTests.kt
@@ -0,0 +1,60 @@
+package org.jetbrains.kotlinx.dataframe.testSets.person
+
+import io.kotest.matchers.shouldBe
+import io.kotest.matchers.string.shouldContain
+import org.jetbrains.kotlinx.dataframe.api.FormattingDSL
+import org.jetbrains.kotlinx.dataframe.api.FormattingDSL.gray
+import org.jetbrains.kotlinx.dataframe.api.FormattingDSL.green
+import org.jetbrains.kotlinx.dataframe.api.FormattingDSL.red
+import org.jetbrains.kotlinx.dataframe.api.and
+import org.jetbrains.kotlinx.dataframe.api.colsOf
+import org.jetbrains.kotlinx.dataframe.api.format
+import org.jetbrains.kotlinx.dataframe.api.linearBg
+import org.jetbrains.kotlinx.dataframe.api.where
+import org.jetbrains.kotlinx.dataframe.api.with
+import org.jetbrains.kotlinx.dataframe.impl.api.encode
+import org.jetbrains.kotlinx.dataframe.impl.api.linearGradient
+import org.jetbrains.kotlinx.dataframe.index
+import org.jetbrains.kotlinx.dataframe.io.DisplayConfiguration
+import org.jetbrains.kotlinx.dataframe.nrow
+import org.junit.Test
+
+class FormattingTests : BaseTest() {
+
+    @Test
+    fun `conditional formatting`() {
+        val formattedFrame = typed.format { colsOf<Int>() }.with {
+            if (it > 10) {
+                background(white) and bold and italic
+            } else {
+                textColor(linear(it, 30.5 to red, 50 to green)) and underline
+            }
+        }
+
+        val formatter = formattedFrame.formatter!!
+        for (row in 0 until typed.nrow) {
+            FormattingDSL.formatter(typed[row], typed.age)!!.attributes().size shouldBe
+                if (typed[row].age > 10) 3 else 2
+        }
+
+        formattedFrame.toHTML(DisplayConfiguration.DEFAULT).toString() shouldContain "font-style:italic"
+    }
+
+    @Test
+    fun `override format`() {
+        val formatter = typed
+            .format { age }.linearBg(20 to green, 80 to red)
+            .format { age and weight }.where { index % 2 == 0 }.with { background(gray) }
+            .formatter!!
+
+        for (row in 0 until typed.nrow step 2) {
+            FormattingDSL.formatter(typed[row], typed.age)!!.attributes() shouldBe
+                listOf("background-color" to gray.encode())
+        }
+
+        for (row in 1 until typed.nrow step 2) {
+            FormattingDSL.formatter(typed[row], typed.age)!!.attributes() shouldBe
+                listOf("background-color" to linearGradient(typed[row].age.toDouble(), 20.0, green, 80.0, red).encode())
+        }
+    }
+}
diff --git a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/testSets/person/HtmlRenderingTests.kt b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/testSets/person/HtmlRenderingTests.kt
new file mode 100644
index 000000000..94d351f01
--- /dev/null
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/testSets/person/HtmlRenderingTests.kt
@@ -0,0 +1,41 @@
+package org.jetbrains.kotlinx.dataframe.testSets.person
+
+import io.kotest.matchers.shouldNotBe
+import io.kotest.matchers.string.shouldContain
+import org.jetbrains.kotlinx.dataframe.AnyFrame
+import org.jetbrains.kotlinx.dataframe.api.dataFrameOf
+import org.jetbrains.kotlinx.dataframe.api.group
+import org.jetbrains.kotlinx.dataframe.api.into
+import org.jetbrains.kotlinx.dataframe.api.parse
+import org.jetbrains.kotlinx.dataframe.io.toStandaloneHTML
+import org.jetbrains.kotlinx.jupyter.util.findNthSubstring
+import org.junit.Ignore
+import org.junit.Test
+import java.awt.Desktop
+import java.io.File
+
+class HtmlRenderingTests : BaseTest() {
+
+    fun AnyFrame.browse() {
+        val file = File("temp.html") // File.createTempFile("df_rendering", ".html")
+        file.writeText(toStandaloneHTML().toString())
+        val uri = file.toURI()
+        val desktop = Desktop.getDesktop()
+        desktop.browse(uri)
+    }
+
+    @Ignore
+    @Test
+    fun test() {
+        typed.group { name and age }.into("temp").browse()
+    }
+
+    @Test
+    fun `render url`() {
+        val address = "http://www.google.com"
+        val df = dataFrameOf("url")(address).parse()
+        val html = df.toStandaloneHTML().toString()
+        html shouldContain "href"
+        html.findNthSubstring(address, 2) shouldNotBe -1
+    }
+}
diff --git a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/testSets/person/JoinTests.kt b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/testSets/person/JoinTests.kt
new file mode 100644
index 000000000..b88e31251
--- /dev/null
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/testSets/person/JoinTests.kt
@@ -0,0 +1,114 @@
+package org.jetbrains.kotlinx.dataframe.testSets.person
+
+import io.kotest.matchers.shouldBe
+import org.jetbrains.kotlinx.dataframe.api.JoinType
+import org.jetbrains.kotlinx.dataframe.api.addId
+import org.jetbrains.kotlinx.dataframe.api.all
+import org.jetbrains.kotlinx.dataframe.api.append
+import org.jetbrains.kotlinx.dataframe.api.column
+import org.jetbrains.kotlinx.dataframe.api.count
+import org.jetbrains.kotlinx.dataframe.api.distinct
+import org.jetbrains.kotlinx.dataframe.api.excludeJoin
+import org.jetbrains.kotlinx.dataframe.api.filter
+import org.jetbrains.kotlinx.dataframe.api.filterJoin
+import org.jetbrains.kotlinx.dataframe.api.fullJoin
+import org.jetbrains.kotlinx.dataframe.api.innerJoin
+import org.jetbrains.kotlinx.dataframe.api.join
+import org.jetbrains.kotlinx.dataframe.api.leftJoin
+import org.jetbrains.kotlinx.dataframe.api.remove
+import org.jetbrains.kotlinx.dataframe.api.rightJoin
+import org.jetbrains.kotlinx.dataframe.api.select
+import org.junit.Test
+
+class JoinTests : BaseJoinTest() {
+
+    @Test
+    fun `inner join`() {
+        val res = typed.innerJoin(typed2) { name and it.city.match(right.origin) }
+        res.columnsCount() shouldBe 6
+        res.rowsCount() shouldBe 7
+        res["age1"].hasNulls() shouldBe false
+        res.count { name == "Charlie" && city == "Moscow" } shouldBe 4
+        res.select { city and name }.distinct().rowsCount() shouldBe 3
+        res[Person2::grade].hasNulls() shouldBe false
+    }
+
+    @Test
+    fun `left join`() {
+        val res = typed.leftJoin(typed2) { name and it.city.match(right.origin) }
+
+        res.columnsCount() shouldBe 6
+        res.rowsCount() shouldBe 10
+        res["age1"].hasNulls() shouldBe true
+        res.select { city and name }.distinct().rowsCount() shouldBe 6
+        res.count { it["grade"] == null } shouldBe 3
+        res.age.hasNulls() shouldBe false
+    }
+
+    @Test
+    fun `right join`() {
+        val res = typed.rightJoin(typed2) { name and it.city.match(right.origin) }
+
+        res.columnsCount() shouldBe 6
+        res.rowsCount() shouldBe 9
+        res["age1"].hasNulls() shouldBe true
+        res.select { city and name }.distinct().rowsCount() shouldBe 4
+        res[Person2::grade].hasNulls() shouldBe false
+        res.age.hasNulls() shouldBe true
+        val newEntries = res.filter { it["age"] == null }
+        newEntries.rowsCount() shouldBe 2
+        newEntries.all { name == "Bob" && city == "Paris" && weight == null } shouldBe true
+    }
+
+    @Test
+    fun `outer join`() {
+        val res = typed.fullJoin(typed2) { name and it.city.match(right.origin) }
+        println(res)
+        res.columnsCount() shouldBe 6
+        res.rowsCount() shouldBe 12
+        res.name.hasNulls() shouldBe false
+        res.columns().filter { it != res.name }.all { it.hasNulls() } shouldBe true
+        res.select { city and name }.distinct().rowsCount() shouldBe 7
+        val distinct = res.select { name and age and city and weight }.distinct()
+        val expected = typed.append("Bob", null, "Paris", null)
+        distinct shouldBe expected
+    }
+
+    @Test
+    fun `filter join`() {
+        val res = typed.filterJoin(typed2) { city.match(right.origin) }
+        val expected = typed.innerJoin(typed2.select { origin }) { city.match(right.origin) }
+        res shouldBe expected
+    }
+
+    @Test
+    fun `filter not join`() {
+        val res = typed.excludeJoin(typed2) { city.match(right.origin) }
+        res.rowsCount() shouldBe 3
+        res.city.toSet() shouldBe typed.city.toSet() - typed2.origin.toSet()
+
+        val indexColumn = column<Int>("__index__")
+        val withIndex = typed.addId(indexColumn)
+        val joined = withIndex.filterJoin(typed2) { city.match(right.origin) }
+        val joinedIndices = joined[indexColumn].toSet()
+        val expected = withIndex.filter { !joinedIndices.contains(it[indexColumn]) }.remove(indexColumn)
+
+        res shouldBe expected
+    }
+
+    @Test
+    fun `test overloads contract`() {
+        typed.innerJoin(typed2) { name and it.city.match(right.origin) } shouldBe
+            typed.join(typed2, JoinType.Inner) { name and it.city.match(right.origin) }
+        typed.leftJoin(typed2) { name and it.city.match(right.origin) } shouldBe
+            typed.join(typed2, JoinType.Left) { name and it.city.match(right.origin) }
+        typed.rightJoin(typed2) { name and it.city.match(right.origin) } shouldBe
+            typed.join(typed2, JoinType.Right) { name and it.city.match(right.origin) }
+        typed.fullJoin(typed2) { name and it.city.match(right.origin) } shouldBe
+            typed.join(typed2, JoinType.Full) { name and it.city.match(right.origin) }
+        typed.excludeJoin(typed2) { city.match(right.origin) } shouldBe
+            typed.join(typed2, JoinType.Exclude) { city.match(right.origin) }
+        typed.filterJoin(typed2) { city.match(right.origin) } shouldBe
+            typed.join(typed2, JoinType.Filter) { city.match(right.origin) }
+    }
+}
diff --git a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/testSets/person/JoinWithTests.kt b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/testSets/person/JoinWithTests.kt
new file mode 100644
index 000000000..c56562c66
--- /dev/null
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/testSets/person/JoinWithTests.kt
@@ -0,0 +1,137 @@
+package org.jetbrains.kotlinx.dataframe.testSets.person
+
+import io.kotest.matchers.shouldBe
+import org.jetbrains.kotlinx.dataframe.api.JoinType
+import org.jetbrains.kotlinx.dataframe.api.addId
+import org.jetbrains.kotlinx.dataframe.api.all
+import org.jetbrains.kotlinx.dataframe.api.append
+import org.jetbrains.kotlinx.dataframe.api.column
+import org.jetbrains.kotlinx.dataframe.api.count
+import org.jetbrains.kotlinx.dataframe.api.dataFrameOf
+import org.jetbrains.kotlinx.dataframe.api.distinct
+import org.jetbrains.kotlinx.dataframe.api.excludeJoin
+import org.jetbrains.kotlinx.dataframe.api.excludeJoinWith
+import org.jetbrains.kotlinx.dataframe.api.filter
+import org.jetbrains.kotlinx.dataframe.api.filterJoinWith
+import org.jetbrains.kotlinx.dataframe.api.fullJoinWith
+import org.jetbrains.kotlinx.dataframe.api.innerJoinWith
+import org.jetbrains.kotlinx.dataframe.api.joinWith
+import org.jetbrains.kotlinx.dataframe.api.leftJoinWith
+import org.jetbrains.kotlinx.dataframe.api.print
+import org.jetbrains.kotlinx.dataframe.api.remove
+import org.jetbrains.kotlinx.dataframe.api.rightJoinWith
+import org.jetbrains.kotlinx.dataframe.api.select
+import org.junit.Test
+
+@Suppress("ktlint:standard:argument-list-wrapping")
+class JoinWithTests : BaseJoinTest() {
+
+    @Test
+    fun `inner join`() {
+        val res = typed.joinWith(typed2) {
+            name == right.name && city == right.origin
+        }
+        res.columnsCount() shouldBe 8
+        res.rowsCount() shouldBe 7
+        res["age1"].hasNulls() shouldBe false
+        res.count { name == "Charlie" && city == "Moscow" } shouldBe 4
+        res.select { city and name }.distinct().rowsCount() shouldBe 3
+        res[Person2::grade].hasNulls() shouldBe false
+    }
+
+    @Test
+    fun `left join`() {
+        val res = typed.leftJoinWith(typed2) { name == right.name && city == right.origin }
+
+        res.columnsCount() shouldBe 8
+        res.rowsCount() shouldBe 10
+        res["age1"].hasNulls() shouldBe true
+        res.select { city and name }.distinct().rowsCount() shouldBe 6
+        res.count { it["grade"] == null } shouldBe 3
+        res.age.hasNulls() shouldBe false
+    }
+
+    @Test
+    fun `right join`() {
+        val res = typed.rightJoinWith(typed2) {
+            name == right.name && city == right.origin
+        }
+        res.columnsCount() shouldBe 8
+        res.rowsCount() shouldBe 9
+        res["age1"].hasNulls() shouldBe true
+        res.select { city and name }.distinct().rowsCount() shouldBe 4
+        res[Person2::grade].hasNulls() shouldBe false
+        res.age.hasNulls() shouldBe true
+        val newEntries = res.filter { it["age"] == null }
+        newEntries.rowsCount() shouldBe 2
+        newEntries.all { it["name1"] == "Bob" && it["origin"] == "Paris" && weight == null } shouldBe true
+    }
+
+    @Test
+    fun `outer join`() {
+        val res = typed.fullJoinWith(typed2) { name == right.name && city == right.origin }
+        println(res)
+        res.columnsCount() shouldBe 8
+        res.rowsCount() shouldBe 12
+        res.columns().all { it.hasNulls() } shouldBe true
+        res.select { city and name }.distinct().rowsCount() shouldBe 7
+        val distinct = res.select { name and age and city and weight }.distinct()
+        val expected = typed.append(null, null, null, null)
+        distinct shouldBe expected
+    }
+
+    @Test
+    fun `filter join`() {
+        val res = typed.filterJoinWith(typed2) { city == right.origin }
+        val expected = typed.innerJoinWith(typed2.select { origin }) { city == right.origin }.remove("origin")
+        res shouldBe expected
+    }
+
+    @Test
+    fun `filter not join`() {
+        val res = typed.excludeJoinWith(typed2) { city == right.origin }
+        res.rowsCount() shouldBe 3
+        res.city.toSet() shouldBe typed.city.toSet() - typed2.origin.toSet()
+
+        val indexColumn = column<Int>("__index__")
+        val withIndex = typed.addId(indexColumn)
+        val joined = withIndex.filterJoinWith(typed2) { city == right.origin }
+        val joinedIndices = joined[indexColumn].toSet()
+        val expected = withIndex.filter { !joinedIndices.contains(it[indexColumn]) }.remove(indexColumn)
+
+        res shouldBe expected
+    }
+
+    @Test
+    fun rightJoin() {
+        val df = dataFrameOf("a", "b")(
+            1, "a",
+            2, "b",
+            3, "c",
+        )
+
+        val df1 = dataFrameOf("a", "c")(
+            5, "V",
+            1, "I",
+            2, "II",
+            3, "III",
+        )
+        df.append(4, "e").excludeJoin(df1).print()
+    }
+
+    @Test
+    fun `test overloads contract`() {
+        typed.innerJoinWith(typed2) { name == right.name && city == right.origin } shouldBe
+            typed.joinWith(typed2, JoinType.Inner) { name == right.name && city == right.origin }
+        typed.leftJoinWith(typed2) { name == right.name && city == right.origin } shouldBe
+            typed.joinWith(typed2, JoinType.Left) { name == right.name && city == right.origin }
+        typed.rightJoinWith(typed2) { name == right.name && city == right.origin } shouldBe
+            typed.joinWith(typed2, JoinType.Right) { name == right.name && city == right.origin }
+        typed.fullJoinWith(typed2) { name == right.name && city == right.origin } shouldBe
+            typed.joinWith(typed2, JoinType.Full) { name == right.name && city == right.origin }
+        typed.excludeJoinWith(typed2) { city == right.origin } shouldBe
+            typed.joinWith(typed2, JoinType.Exclude) { city == right.origin }
+        typed.filterJoinWith(typed2) { city == right.origin } shouldBe
+            typed.joinWith(typed2, JoinType.Filter) { city == right.origin }
+    }
+}
diff --git a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/testSets/person/PivotTests.kt b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/testSets/person/PivotTests.kt
new file mode 100644
index 000000000..ddbd57f36
--- /dev/null
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/testSets/person/PivotTests.kt
@@ -0,0 +1,592 @@
+package org.jetbrains.kotlinx.dataframe.testSets.person
+
+import io.kotest.matchers.shouldBe
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.annotations.DataSchema
+import org.jetbrains.kotlinx.dataframe.api.Infer
+import org.jetbrains.kotlinx.dataframe.api.add
+import org.jetbrains.kotlinx.dataframe.api.aggregate
+import org.jetbrains.kotlinx.dataframe.api.asColumnGroup
+import org.jetbrains.kotlinx.dataframe.api.associate
+import org.jetbrains.kotlinx.dataframe.api.cast
+import org.jetbrains.kotlinx.dataframe.api.column
+import org.jetbrains.kotlinx.dataframe.api.columnNames
+import org.jetbrains.kotlinx.dataframe.api.columnOf
+import org.jetbrains.kotlinx.dataframe.api.columnsCount
+import org.jetbrains.kotlinx.dataframe.api.convert
+import org.jetbrains.kotlinx.dataframe.api.count
+import org.jetbrains.kotlinx.dataframe.api.dataFrameOf
+import org.jetbrains.kotlinx.dataframe.api.drop
+import org.jetbrains.kotlinx.dataframe.api.dropNulls
+import org.jetbrains.kotlinx.dataframe.api.explodeLists
+import org.jetbrains.kotlinx.dataframe.api.expr
+import org.jetbrains.kotlinx.dataframe.api.filter
+import org.jetbrains.kotlinx.dataframe.api.first
+import org.jetbrains.kotlinx.dataframe.api.frames
+import org.jetbrains.kotlinx.dataframe.api.gather
+import org.jetbrains.kotlinx.dataframe.api.getColumnGroup
+import org.jetbrains.kotlinx.dataframe.api.getColumns
+import org.jetbrains.kotlinx.dataframe.api.getColumnsWithPaths
+import org.jetbrains.kotlinx.dataframe.api.group
+import org.jetbrains.kotlinx.dataframe.api.groupBy
+import org.jetbrains.kotlinx.dataframe.api.groupByOther
+import org.jetbrains.kotlinx.dataframe.api.implode
+import org.jetbrains.kotlinx.dataframe.api.into
+import org.jetbrains.kotlinx.dataframe.api.isColumnGroup
+import org.jetbrains.kotlinx.dataframe.api.isList
+import org.jetbrains.kotlinx.dataframe.api.join
+import org.jetbrains.kotlinx.dataframe.api.last
+import org.jetbrains.kotlinx.dataframe.api.map
+import org.jetbrains.kotlinx.dataframe.api.mapKeys
+import org.jetbrains.kotlinx.dataframe.api.mapValues
+import org.jetbrains.kotlinx.dataframe.api.matches
+import org.jetbrains.kotlinx.dataframe.api.named
+import org.jetbrains.kotlinx.dataframe.api.notNull
+import org.jetbrains.kotlinx.dataframe.api.pivot
+import org.jetbrains.kotlinx.dataframe.api.print
+import org.jetbrains.kotlinx.dataframe.api.remove
+import org.jetbrains.kotlinx.dataframe.api.replace
+import org.jetbrains.kotlinx.dataframe.api.rows
+import org.jetbrains.kotlinx.dataframe.api.sortBy
+import org.jetbrains.kotlinx.dataframe.api.sumOf
+import org.jetbrains.kotlinx.dataframe.api.toInt
+import org.jetbrains.kotlinx.dataframe.api.ungroup
+import org.jetbrains.kotlinx.dataframe.api.update
+import org.jetbrains.kotlinx.dataframe.api.values
+import org.jetbrains.kotlinx.dataframe.api.where
+import org.jetbrains.kotlinx.dataframe.api.with
+import org.jetbrains.kotlinx.dataframe.columns.ColumnKind
+import org.jetbrains.kotlinx.dataframe.impl.asList
+import org.jetbrains.kotlinx.dataframe.impl.nothingType
+import org.jetbrains.kotlinx.dataframe.io.renderToString
+import org.jetbrains.kotlinx.dataframe.typeClass
+import org.junit.Test
+import java.util.AbstractSet
+import kotlin.reflect.KClass
+import kotlin.reflect.typeOf
+
+@Suppress("ktlint:standard:argument-list-wrapping")
+class PivotTests {
+
+    val df = dataFrameOf(
+        "name", "key", "value",
+    )(
+        "Alice", "age", 15,
+        "Alice", "city", "London",
+        "Alice", "weight", 54,
+        "Bob", "age", 45,
+        "Bob", "weight", 87,
+        "Charlie", "age", 20,
+        "Charlie", "city", "Moscow",
+        "Charlie", "weight", null,
+        "Alice", "age", 55,
+    )
+
+    val defaultExpected = dataFrameOf(
+        "name", "age", "city", "weight",
+    )(
+        "Alice", listOf(15, 55), "London", 54,
+        "Bob", listOf(45), "-", 87,
+        "Charlie", listOf(20), "Moscow", "-",
+    )
+
+// Generated Code
+
+    @DataSchema
+    interface Person {
+        val name: String
+        val key: String
+        val value: Any?
+    }
+
+    val typed: DataFrame<Person> = df.cast()
+
+    val name by column<String>()
+    val key by column<String>()
+    val value by column<Any?>()
+
+// Tests
+
+    val keyConverter: (String) -> String = { "__$it" }
+    val valueConverter: (Any?) -> Any? = { (it as? Int)?.toDouble() ?: it }
+
+    val expectedFiltered = typed.dropNulls { value }.sortBy { name and key }
+
+    @Test
+    fun `pivot matches`() {
+        val filtered = typed.drop(1)
+        val res = filtered.pivot(inward = false) { key }.groupBy { name }.matches()
+        res.columnsCount() shouldBe 1 + filtered.key.countDistinct()
+        res.rowsCount() shouldBe filtered.name.countDistinct()
+
+        val expected = filtered.rows().map { (it.name to it.key) }.toSet()
+        val actual = res.columns()
+            .subList(1, res.columnsCount())
+            .flatMap {
+                val columnName = it.name()
+                res.rows().mapNotNull {
+                    val value = it[columnName] as Boolean
+                    if (value) {
+                        (it.name to columnName)
+                    } else {
+                        null
+                    }
+                }
+            }.toSet()
+
+        actual shouldBe expected
+        res["age"].type() shouldBe typeOf<Boolean>()
+        res["city"].type() shouldBe typeOf<Boolean>()
+        res["weight"].type() shouldBe typeOf<Boolean>()
+    }
+
+    @Test
+    fun `simple pivot`() {
+        val res = typed.pivot { key }.groupBy { name }.values { value default "-" }
+
+        res.columnsCount() shouldBe 2
+        res.rowsCount() shouldBe typed.name.countDistinct()
+
+        val data = res.getColumnGroup("key")
+
+        data["age"].type() shouldBe typeOf<List<Int>>()
+        data["city"].type() shouldBe typeOf<String>()
+        data["weight"].type() shouldBe typeOf<Comparable<*>>() // Comparable<String + Int> -> Comparable<Nothing | *>
+
+        res.renderToString(columnTypes = true, title = true) shouldBe
+            defaultExpected.group { drop(1) }.into("key").renderToString(columnTypes = true, title = true)
+
+        typed
+            .pivot { key }
+            .groupBy { name }
+            .default("-")
+            .values { value } shouldBe res
+        typed
+            .pivot { key }
+            .groupBy { name }
+            .default("-")
+            .with { value } shouldBe res
+        df
+            .pivot { key }
+            .groupBy { name }
+            .default("-")
+            .values { value } shouldBe res
+        df
+            .pivot(key)
+            .groupBy(name)
+            .default("-")
+            .values(value) shouldBe res
+        df
+            .pivot(key)
+            .groupBy(name)
+            .default("-")
+            .with { value } shouldBe res
+        typed
+            .groupBy { name }
+            .pivot { key }
+            .default("-")
+            .values { value } shouldBe res
+
+        typed
+            .pivot { key }
+            .groupBy { name }
+            .default("-")
+            .with { value.toString() }
+    }
+
+    @Test
+    fun `pivot with transform`() {
+        val pivoted = typed.pivot { key.map { "_$it" } }.groupBy { name }.with { value }
+        pivoted.getColumns { "key".allCols() }.map { it.name() }.toSet() shouldBe
+            typed.key
+                .distinct()
+                .map { "_$it" }
+                .toSet()
+    }
+
+    @Test
+    fun `pivot with index transform`() {
+        val pivoted = typed.pivot { key }.groupBy { name.map { "_$it" } }.with { value }
+        pivoted.name shouldBe typed.name.distinct().map { "_$it" }
+    }
+
+    @Test
+    fun `pivot with value map`() {
+        val pivoted = typed.pivot(inward = false) { key }.groupBy { name }.values { value.map { "_$it" } }
+
+        pivoted shouldBe dataFrameOf("name", "age", "city", "weight")(
+            "Alice", listOf("_15", "_55"), "_London", "_54",
+            "Bob", listOf("_45"), null, "_87",
+            "Charlie", listOf("_20"), "_Moscow", "_null",
+        )
+    }
+
+    @Test
+    fun `pivot two values`() {
+        val pivoted = typed
+            .pivot(inward = false) { key }
+            .groupBy { name }
+            .values { value and (expr { value?.toString() } into "str") default "-" }
+
+        val expected = defaultExpected.replace("age", "city", "weight").with {
+            columnOf(
+                it named "value",
+                it.map(Infer.Type) {
+                    if (it is List<*>) {
+                        it.map { it?.toString() }.asList()
+                    } else {
+                        it?.toString()
+                    }
+                } named "str",
+            ) named it.name()
+        }
+
+        pivoted.renderToString(title = true, columnTypes = true) shouldBe expected.renderToString(
+            title = true,
+            columnTypes = true,
+        )
+    }
+
+    @Test
+    fun `pivot two values group by value`() {
+        val type by column<KClass<*>?>()
+        val pivoted = typed
+            .add(type) { value?.javaClass?.kotlin }
+            .pivot { key }.groupBy { name }.values(separate = true) { value and type }
+        pivoted.columnsCount() shouldBe 3
+    }
+
+    @Test
+    fun `pivot two columns with then`() {
+        val pivoted = typed
+            .add("index") { 1 }
+            .pivot(inward = false) { name then key }
+            .groupBy("index")
+            .with { value }
+
+        pivoted.columnNames() shouldBe listOf("index") + typed.name.distinct().values()
+        pivoted.rowsCount() shouldBe 1
+
+        val keys = typed.key.distinct().values()
+        pivoted.columns().drop(1).forEach {
+            val group = it.asColumnGroup()
+            group.columnNames() shouldBe if (it.name() == "Bob") keys - "city" else keys
+        }
+
+        val leafColumns = pivoted.getColumnsWithPaths {
+            all()
+                .drop(1)
+                .colsAtAnyDepth { !it.isColumnGroup() }
+        }
+        leafColumns.size shouldBe typed.name.countDistinct() * typed.key.countDistinct() - 1
+        leafColumns.forEach { it.path.size shouldBe 2 }
+
+        val data = leafColumns.associate { it.path[0] to it.path[1] to it.data[0] }
+        val expected = typed.associate { name to key to value }.toMutableMap()
+        expected["Alice" to "age"] = listOf(15, 55)
+        data shouldBe expected
+
+        val pivotedNoIndex = typed.pivot { name then key }.with { value }
+        pivotedNoIndex shouldBe pivoted.remove("index")[0]
+    }
+
+    @Test
+    fun `pivot two columns with and`() {
+        val withIndex = typed.add("index") { 1 }
+        val pivoted = withIndex.pivot { name and key }.groupBy("index").with { value }
+        pivoted shouldBe
+            withIndex
+                .pivot(inward = true) { name }.groupBy("index").with { value }
+                .join(withIndex.pivot(inward = true) { key }.groupBy("index").with { value })
+
+        val pivotedNoIndex = typed.pivot { name and key }.with { value }
+        pivotedNoIndex shouldBe pivoted.remove("index")[0]
+    }
+
+    @Test
+    fun `pivot with two index columns`() {
+        val pivoted = typed
+            .dropNulls { value }
+            .pivot { value.map { it!!.javaClass.kotlin.simpleName } }.groupBy { name and key }.with { value }
+
+        val expected = typed
+            .dropNulls { value }
+            .add {
+                "Int" from { value as? Int }
+                "String" from { value as? String }
+            }
+            .remove("value")
+            .implode("Int", dropNA = true)
+            .group("Int", "String").into("value")
+
+        pivoted shouldBe expected
+    }
+
+    @Test
+    fun `pivot two values without groupBy`() {
+        typed.print(columnTypes = true)
+        val pivotedRow = typed
+            .pivot { name then key }
+            .values { value and (value.map { it?.javaClass?.kotlin } into "type") }
+
+        val pivotedDf = pivotedRow.df()
+        pivotedRow.columnsCount() shouldBe typed.name.countDistinct()
+
+        val nullGroup = pivotedDf["Charlie"]["weight"].asColumnGroup()
+        nullGroup.columnNames() shouldBe listOf("value", "type")
+//        nullGroup.columnTypes() shouldBe listOf(typeOf<Comparable<*>?>(), typeOf<KClass<Any>?>())
+        nullGroup.columnTypes() shouldBe listOf(nothingType(true), nothingType(true))
+
+        val cols = pivotedDf.getColumnsWithPaths { colsAtAnyDepth { !it.isColumnGroup() } }
+        cols.size shouldBe 2 * typed.name.countDistinct() * typed.key.countDistinct() - 2
+
+        cols.forEach {
+            when {
+                it.isList() -> it.path().dropLast(1) shouldBe listOf("Alice", "age")
+
+                it.hasNulls() -> {
+                    it.path().dropLast(1) shouldBe listOf("Charlie", "weight")
+                }
+
+                it.name() == "type" -> it.typeClass shouldBe KClass::class
+
+                else -> it.name() shouldBe "value"
+            }
+        }
+        pivotedRow.getColumnGroup("Bob").getColumnGroup("weight")["value"] shouldBe 87
+    }
+
+    @Test
+    fun `pivot two values without index group by value`() {
+        val pivoted = typed.pivot { name }.values(separate = true) { key and value }
+        pivoted.df().columnNames() shouldBe listOf("key", "value")
+        (pivoted.getColumnGroup("key")["Alice"] as List<String>).size shouldBe 4
+        pivoted.df().getColumnGroup("value")["Bob"].type() shouldBe typeOf<List<Int>>()
+        pivoted.getColumnGroup("value")["Bob"] shouldBe listOf(45, 87)
+    }
+
+    @Test
+    fun `pivot in group aggregator`() {
+        val pivoted = typed.groupBy { name }.aggregate {
+            pivot { key }.with { value } into "key"
+        }
+        pivoted.columnsCount() shouldBe 2
+        pivoted.print()
+        pivoted.ungroup("key") shouldBe typed.pivot(inward = false) { key }.groupBy { name }.with { value }
+    }
+
+    @Test
+    fun `equal pivots`() {
+        val expected = typed.pivot { key }.groupBy { name }.with { value }
+        typed.groupBy { name }.pivot { key }.values { value } shouldBe expected
+        val pivoted = typed.groupBy { name }.aggregate {
+            pivot { key }.with { value }
+        }
+        pivoted.print()
+        pivoted shouldBe expected
+    }
+
+    @Test
+    fun gather() {
+        val res = typed.pivot(inward = false) { key }.groupBy { name }.with { value }
+        val gathered = res.gather { drop(1) }.notNull().into("key", "value")
+        gathered shouldBe typed.dropNulls { value }.sortBy { name and "key" }
+    }
+
+    @Test
+    fun `gather with filter`() {
+        val pivoted = typed.pivot { key }.groupBy { name }.with { value }
+        val gathered = pivoted
+            .gather { "key".allCols() }.explodeLists().where { it is Int }.into("key", "value")
+        gathered shouldBe typed
+            .filter { value is Int }
+            .sortBy("name", "key")
+            .convert("value").toInt() // TODO: replace convert with cast
+    }
+
+    @Test
+    fun `grouped pivot with key and value conversions`() {
+        val grouped = typed.groupBy { name }
+
+        val pivoted = grouped.pivot(inward = false) { key.map(transform = keyConverter) }.with { valueConverter(value) }
+
+        val pivoted2 = grouped.aggregate {
+            pivot(inward = false) { key.map(transform = keyConverter) }.with { valueConverter(value) }
+        }
+
+        val pivoted3 =
+            typed
+                .pivot(inward = false) { key.map(transform = keyConverter) }
+                .groupBy { name }
+                .values { value.map(transform = valueConverter) }
+
+        pivoted2 shouldBe pivoted
+        pivoted3 shouldBe pivoted
+
+        val gathered = pivoted
+            .gather { drop(1) }.notNull().into("key", "value")
+            .convert { value }
+            .with { it as? Comparable<*> } // cast to make the equality test succeed (values are already the same)
+        val expected = expectedFiltered
+            .update { key }.with { keyConverter(it) }
+            .convert { value }.with { valueConverter(it) as? Comparable<*> }
+        gathered shouldBe expected
+    }
+
+    @Test
+    fun `gather with value conversion`() {
+        val pivoted = typed.pivot { key }.groupBy { name }.with { valueConverter(value) }
+        val gathered =
+            pivoted
+                .gather { "key".allCols() }
+                .explodeLists()
+                .notNull()
+                .mapValues { (it as? Double)?.toInt() ?: it }.into("key", "value")
+        gathered shouldBe expectedFiltered
+    }
+
+    @Test
+    fun `gather doubles with value conversion`() {
+        val pivoted = typed.pivot { key }.groupBy { name }.with { valueConverter(value) }
+        val gathered = pivoted.remove { "key"["city"] }
+            .gather { "key".allCols() }
+            .explodeLists()
+            .notNull()
+            .cast<Double>()
+            .mapValues { it.toInt() }.into("key", "value")
+        val expected = typed.filter { key != "city" && value != null }
+            .convert { value }.toInt()
+            .sortBy { name and key }
+        gathered shouldBe expected
+    }
+
+    @Test
+    fun `gather with name conversion`() {
+        val pivoted = typed.pivot { key.map(transform = keyConverter) }.groupBy { name }.with { value }
+        val gathered = pivoted
+            .gather { "key".allCols() }
+            .notNull()
+            .mapKeys { it.substring(2) }.into("key", "value")
+        gathered shouldBe expectedFiltered
+    }
+
+    @Test
+    fun `type arguments inference in pivot with index`() {
+        val id by columnOf(1, 1, 2, 2)
+        val name by columnOf("set", "list", "set", "list")
+        val data by columnOf(setOf(1), listOf(1), setOf(2), listOf(2))
+        val df = dataFrameOf(id, name, data)
+        df[data].type() shouldBe typeOf<Collection<Int>>()
+        val pivoted = df.pivot(inward = false) { name }.groupBy { id }.values { data }
+        pivoted.rowsCount() shouldBe 2
+        pivoted.columnsCount() shouldBe 3
+        pivoted["set"].type() shouldBe typeOf<AbstractSet<Int>>()
+        pivoted["list"].type() shouldBe typeOf<List<Int>>()
+    }
+
+    @Test
+    fun `type arguments inference in pivot`() {
+        val name by columnOf("set", "list")
+        val data by columnOf(setOf(1), listOf(1))
+        val df = dataFrameOf(name, data)
+        df[data].type() shouldBe typeOf<Collection<Int>>()
+        val pivoted = df.pivot { name }.values { data }
+        pivoted.columnsCount() shouldBe 2
+        pivoted.df()["set"].type() shouldBe typeOf<AbstractSet<Int>>()
+        pivoted.df()["list"].type() shouldBe typeOf<List<Int>>()
+    }
+
+    @Test
+    fun `pivot with grouping`() {
+        val pivoted = typed.pivot(inward = true) { key }.groupBy { name }.with { value }
+        pivoted.columnNames() shouldBe listOf("name", "key")
+        pivoted["key"].asColumnGroup().columnNames() shouldBe typed.key.distinct().values()
+    }
+
+    @Test
+    fun `pivot matches yes no`() {
+        val pivoted = typed.drop(1)
+            .pivot(inward = false) { key }.groupBy { name }
+            .matches("yes", "no")
+        pivoted.sumOf { values().count { it == "yes" } } shouldBe typed.rowsCount() - 1
+        pivoted.sumOf { values().count { it == "no" } } shouldBe 1
+    }
+
+    @Test
+    fun `pivot aggregate into`() {
+        val pivoted = typed.pivot(inward = false) { key }.groupBy { name }.aggregate {
+            value.first() into "value"
+        }
+        pivoted.columns().drop(1).forEach {
+            it.kind() shouldBe ColumnKind.Group
+            it.asColumnGroup().columnNames() shouldBe listOf("value")
+        }
+    }
+
+    @Test
+    fun `pivot aggregate several into`() {
+        val pivoted = typed.pivot { key }.groupBy { name }.aggregate {
+            value.first() into "first value"
+            value.last() into "last value"
+            "unused"
+        }
+        pivoted.getColumnGroup("key").columns().forEach {
+            it.kind() shouldBe ColumnKind.Group
+            it.asColumnGroup().columnNames() shouldBe listOf("first value", "last value")
+        }
+    }
+
+    @Test
+    fun `pivot two value columns into one name`() {
+        val type by column<KClass<*>>()
+
+        val pivoted =
+            typed.add(type) { value?.javaClass?.kotlin ?: Unit::class }
+                .pivot { key }.groupBy { name }
+                .values { value and (type default Any::class) into "data" }
+
+        pivoted.getColumnGroup("key").columns().forEach {
+            val group = it.asColumnGroup()
+            group.columnNames() shouldBe listOf("data")
+            group["data"].asColumnGroup().columnNames() shouldBe listOf("value", "type")
+            group["data"]["type"].hasNulls() shouldBe false
+        }
+    }
+
+    @Test
+    fun `pivot one value without index`() {
+        val pivoted = typed.pivot { name then key }.with { value }
+        pivoted.columnNames() shouldBe typed.name.distinct().values()
+        pivoted.df()["Alice"].asColumnGroup().columnNames() shouldBe typed.key.distinct().values()
+        pivoted.df()["Bob"].asColumnGroup().columnNames() shouldBe listOf("age", "weight")
+        pivoted.df()["Charlie"].asColumnGroup().columnNames() shouldBe typed.key.distinct().values()
+        pivoted.df()["Alice"]["age"].type() shouldBe typeOf<List<Int>>()
+        pivoted.df()["Charlie"]["weight"].type() shouldBe nothingType(true)
+    }
+
+    @Test
+    fun `pivot plain`() {
+        val pivoted = typed.pivot { name }.frames()
+        pivoted.columnNames() shouldBe typed.name.distinct().toList()
+        pivoted["Bob"] shouldBe typed.filter { name == "Bob" }
+    }
+
+    @Test
+    fun `pivot columns inward`() {
+        typed.pivot(inward = true) { name }.count().columnsCount() shouldBe 1
+        typed.pivot { name }.count() shouldBe typed.pivot(inward = false) { name }.count()
+
+        typed.pivot { name and key }.count().columnNames() shouldBe listOf("name", "key")
+        typed.pivot(inward = false) { name and key }.count()
+            .columnsCount() shouldBe typed.name.countDistinct() + typed.key.countDistinct()
+        typed.pivot(inward = true) { name and key }.count() shouldBe typed.pivot { name and key }.count()
+    }
+
+    @Test
+    fun `pivot from group`() {
+        val pivoted = typed
+            .group { key and value }.into("info")
+            .pivot(inward = true) { "info"["value"] }.groupByOther().count()
+        pivoted.getColumnGroup("info").getColumnGroup("value").columnsCount() shouldBe typed.value.countDistinct()
+    }
+}
diff --git a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/testSets/person2/Base.kt b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/testSets/person2/Base.kt
new file mode 100644
index 000000000..4fb9f1a20
--- /dev/null
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/testSets/person2/Base.kt
@@ -0,0 +1,37 @@
+package org.jetbrains.kotlinx.dataframe.testSets.person2
+
+import org.jetbrains.kotlinx.dataframe.DataRow
+import org.jetbrains.kotlinx.dataframe.annotations.DataSchema
+import org.jetbrains.kotlinx.dataframe.api.cast
+import org.jetbrains.kotlinx.dataframe.api.dataFrameOf
+import org.jetbrains.kotlinx.dataframe.api.group
+import org.jetbrains.kotlinx.dataframe.api.into
+
+open class Base {
+    @Suppress("ktlint:standard:argument-list-wrapping")
+    val df = dataFrameOf("firstName", "lastName", "age", "city", "weight")(
+        "Alice", "Cooper", 15, "London", 54,
+        "Bob", "Dylan", 45, "Dubai", 87,
+        "Mark", "Antony", 20, "Moscow", null,
+        "Mark", "Avrely", 40, "Milan", null,
+        "Bob", "Marley", 30, "Tokyo", 68,
+        "Alice", "Lindt", 20, null, 55,
+        "Mark", "Petrov", 30, "Moscow", 90,
+    ).group("firstName", "lastName")
+        .into("name")
+        .cast<Person>()
+
+    @DataSchema
+    interface FullName {
+        val firstName: String
+        val lastName: String
+    }
+
+    @DataSchema
+    interface Person {
+        val name: DataRow<FullName>
+        val age: Int
+        val city: String?
+        val weight: Int?
+    }
+}
diff --git a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/testSets/person2/merge.kt b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/testSets/person2/merge.kt
new file mode 100644
index 000000000..c45681048
--- /dev/null
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/testSets/person2/merge.kt
@@ -0,0 +1,22 @@
+package org.jetbrains.kotlinx.dataframe.testSets.person2
+
+import io.kotest.matchers.shouldBe
+import org.jetbrains.kotlinx.dataframe.api.by
+import org.jetbrains.kotlinx.dataframe.api.into
+import org.jetbrains.kotlinx.dataframe.api.merge
+import org.jetbrains.kotlinx.dataframe.api.remove
+import org.jetbrains.kotlinx.dataframe.api.rename
+import org.junit.Test
+
+class MergeTests : Base() {
+
+    @Test
+    fun `merge inplace`() {
+        val merged = df.merge { name.firstName and city }.by { it[0] + " from " + it[1] }.into("name")
+
+        merged shouldBe
+            df.merge { name.firstName and city }.by { it[0] + " from " + it[1] }.into("name2")
+                .remove { name }
+                .rename("name2" to "name")
+    }
+}
diff --git a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/testSets/person2/replace.kt b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/testSets/person2/replace.kt
new file mode 100644
index 000000000..8e34ef67c
--- /dev/null
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/testSets/person2/replace.kt
@@ -0,0 +1,21 @@
+package org.jetbrains.kotlinx.dataframe.testSets.person2
+
+import io.kotest.matchers.shouldBe
+import org.jetbrains.kotlinx.dataframe.api.asColumnGroup
+import org.jetbrains.kotlinx.dataframe.api.byDesc
+import org.jetbrains.kotlinx.dataframe.api.reorder
+import org.jetbrains.kotlinx.dataframe.api.replace
+import org.jetbrains.kotlinx.dataframe.api.select
+import org.jetbrains.kotlinx.dataframe.api.with
+import org.junit.Test
+
+class ReplaceTests : Base() {
+
+    @Test
+    fun `reorder columns in group`() {
+        val reordered = df.replace { name }.with {
+            it.asColumnGroup().select { lastName and firstName }.asColumnGroup(it.name())
+        }
+        reordered shouldBe df.reorder { name.firstName and name.lastName }.byDesc { it.name() }
+    }
+}
diff --git a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/testSets/weather/SeriesTests.kt b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/testSets/weather/SeriesTests.kt
new file mode 100644
index 000000000..f7e64e71e
--- /dev/null
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/testSets/weather/SeriesTests.kt
@@ -0,0 +1,83 @@
+package org.jetbrains.kotlinx.dataframe.testSets.weather
+
+import io.kotest.matchers.shouldBe
+import org.jetbrains.kotlinx.dataframe.annotations.DataSchema
+import org.jetbrains.kotlinx.dataframe.api.add
+import org.jetbrains.kotlinx.dataframe.api.cast
+import org.jetbrains.kotlinx.dataframe.api.concat
+import org.jetbrains.kotlinx.dataframe.api.dataFrameOf
+import org.jetbrains.kotlinx.dataframe.api.diff
+import org.jetbrains.kotlinx.dataframe.api.groupBy
+import org.jetbrains.kotlinx.dataframe.api.movingAverage
+import org.jetbrains.kotlinx.dataframe.api.rows
+import org.jetbrains.kotlinx.dataframe.api.sortBy
+import org.junit.Test
+
+@Suppress("ktlint:standard:argument-list-wrapping")
+class SeriesTests {
+
+    val df = dataFrameOf("city", "day", "temp")(
+        "Moscow", 1, 14,
+        "London", 1, 10,
+        "Moscow", 3, 18,
+        "London", 3, 16,
+        "Moscow", 6, 16,
+        "London", 6, 23,
+        "Moscow", 4, 13,
+        "London", 4, 22,
+        "Moscow", 2, 20,
+        "London", 2, 15,
+        "Moscow", 5, 10,
+        "London", 5, 18,
+    )
+
+    // Generated code
+
+    @DataSchema
+    interface Weather {
+        val city: String
+        val day: Int
+        val temp: Int
+    }
+
+    val typed = df.cast<Weather>()
+
+    @Test
+    fun `diff test`() {
+        val withDiff = typed
+            .sortBy { city and day }
+            .groupBy { city }
+            .add("diff") { diff(0) { temp } }
+            .concat()
+
+        val srcData = typed.rows().associate { (it.city to it.day) to it.temp }
+        val expected = typed.sortBy { city and day }.rows().map { row ->
+            srcData[row.city to (row.day - 1)]
+                ?.let { row.temp - it }
+                ?: 0
+        }
+        withDiff["diff"].toList() shouldBe expected
+    }
+
+    @Test
+    fun `movingAverage`() {
+        val k = 3
+        val withMa = typed
+            .groupBy { city }
+            .sortBy { city and day }
+            .add("ma_temp") { it.movingAverage(k) { it.temp } }
+            .concat()
+
+        val srcData = typed.rows().map { (it.city to it.day) to it.temp }.toMap()
+        val expected = typed
+            .sortBy { city and day }
+            .rows()
+            .map { row ->
+                (0 until k).mapNotNull { srcData[row.city to row.day - it] }.let {
+                    it.sum().toDouble() / it.size
+                }
+            }
+
+        withMa["ma_temp"].toList() shouldBe expected
+    }
+}
diff --git a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/types/DoubleTests.kt b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/types/DoubleTests.kt
new file mode 100644
index 000000000..9c81304aa
--- /dev/null
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/types/DoubleTests.kt
@@ -0,0 +1,21 @@
+package org.jetbrains.kotlinx.dataframe.types
+
+import io.kotest.matchers.shouldBe
+import org.jetbrains.kotlinx.dataframe.api.columnOf
+import org.jetbrains.kotlinx.dataframe.api.dataFrameOf
+import org.jetbrains.kotlinx.dataframe.api.filter
+import org.jetbrains.kotlinx.dataframe.api.isNaN
+import org.jetbrains.kotlinx.dataframe.nrow
+import org.junit.Test
+
+class DoubleTests {
+
+    @Test
+    fun `filter not null with nans`() {
+        val age by columnOf(2.3, Double.NaN, 1.0, "asd", 3, 'a')
+        val df = dataFrameOf(age)
+        df.filter { age() == Double.NaN }.nrow shouldBe 1
+        df.filter { age().isNaN }.nrow shouldBe 1
+        df.filter { it[age].isNaN }.nrow shouldBe 1
+    }
+}
diff --git a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/types/TypeProjectionTests.kt b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/types/TypeProjectionTests.kt
new file mode 100644
index 000000000..b491d7a0b
--- /dev/null
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/types/TypeProjectionTests.kt
@@ -0,0 +1,67 @@
+package org.jetbrains.kotlinx.dataframe.types
+
+import io.kotest.matchers.shouldBe
+import org.jetbrains.kotlinx.dataframe.DataRow
+import org.jetbrains.kotlinx.dataframe.columns.ColumnGroup
+import org.jetbrains.kotlinx.dataframe.columns.ColumnReference
+import org.jetbrains.kotlinx.dataframe.columns.SingleColumn
+import org.jetbrains.kotlinx.dataframe.impl.columns.ColumnGroupWithParent
+import org.jetbrains.kotlinx.dataframe.impl.commonType
+import org.jetbrains.kotlinx.dataframe.impl.createTypeUsing
+import org.junit.Test
+import kotlin.reflect.typeOf
+
+class TypeProjectionTests {
+    class TypeInferenceTest1 {
+        interface A<T>
+
+        interface X<T> : A<List<T>>
+
+        @Test
+        fun test() {
+            X::class.createTypeUsing<A<List<Int>>>() shouldBe typeOf<X<Int>>()
+            A::class.createTypeUsing<X<Int>>() shouldBe typeOf<A<List<Int>>>()
+        }
+    }
+
+    class TypeInferenceTest2 {
+        interface A<out T>
+
+        interface B<T> : A<A<T>>
+
+        interface C<T> : A<B<T>>
+
+        interface D<T>
+
+        interface X<T : Number, V : Number> :
+            C<T>,
+            D<V>
+
+        @Test
+        fun test() {
+            X::class.createTypeUsing<A<A<A<Int>>>>() shouldBe typeOf<X<Int, *>>()
+            A::class.createTypeUsing<X<Double, Int>?>() shouldBe typeOf<A<B<Double>>?>()
+        }
+    }
+
+    @Test
+    fun `collection to list projection`() {
+        List::class.createTypeUsing<Collection<Int>?>() shouldBe typeOf<List<Int>?>()
+        Collection::class.createTypeUsing<List<Int>>() shouldBe typeOf<Collection<Int>>()
+    }
+
+    @Test
+    fun `column group projections`() {
+        ColumnGroup::class.createTypeUsing<ColumnReference<DataRow<Int>>>() shouldBe typeOf<ColumnGroup<Int>>()
+        SingleColumn::class.createTypeUsing<ColumnGroupWithParent<Int>>() shouldBe typeOf<SingleColumn<DataRow<Int>>>()
+    }
+
+    @Test
+    fun `common type tests`() {
+        listOf(typeOf<List<Int>>(), typeOf<Set<Double?>>()).commonType() shouldBe typeOf<Collection<out Number?>>()
+        listOf(typeOf<List<Int>>(), typeOf<Set<*>>()).commonType(false) shouldBe typeOf<Collection<out Any?>>()
+        listOf(typeOf<List<Int>>(), typeOf<Set<*>>()).commonType() shouldBe typeOf<Collection<*>>()
+        listOf(typeOf<List<Int>>(), typeOf<Set<*>?>()).commonType(false) shouldBe typeOf<Collection<out Any?>?>()
+        listOf(typeOf<List<Int>>(), typeOf<Set<*>?>()).commonType() shouldBe typeOf<Collection<*>?>()
+    }
+}
diff --git a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/types/UtilTests.kt b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/types/UtilTests.kt
new file mode 100644
index 000000000..95cf67b93
--- /dev/null
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/types/UtilTests.kt
@@ -0,0 +1,401 @@
+package org.jetbrains.kotlinx.dataframe.types
+
+import io.kotest.matchers.shouldBe
+import org.jetbrains.kotlinx.dataframe.impl.asArrayAsListOrNull
+import org.jetbrains.kotlinx.dataframe.impl.commonParent
+import org.jetbrains.kotlinx.dataframe.impl.commonParents
+import org.jetbrains.kotlinx.dataframe.impl.commonType
+import org.jetbrains.kotlinx.dataframe.impl.commonTypeListifyValues
+import org.jetbrains.kotlinx.dataframe.impl.createType
+import org.jetbrains.kotlinx.dataframe.impl.guessValueType
+import org.jetbrains.kotlinx.dataframe.impl.isArray
+import org.jetbrains.kotlinx.dataframe.impl.isPrimitiveArray
+import org.jetbrains.kotlinx.dataframe.impl.nothingType
+import org.jetbrains.kotlinx.dataframe.impl.replaceGenericTypeParametersWithUpperbound
+import org.junit.Test
+import java.io.Serializable
+import kotlin.reflect.KClass
+import kotlin.reflect.KType
+import kotlin.reflect.typeOf
+
+class UtilTests {
+
+    @OptIn(ExperimentalUnsignedTypes::class)
+    @Test
+    fun `isArray tests`() {
+        // KClass isArray
+        BooleanArray::class.isArray shouldBe true
+        UIntArray::class.isArray shouldBe true
+        Array::class.isArray shouldBe true
+
+        // KClass isPrimitiveArray
+        BooleanArray::class.isPrimitiveArray shouldBe true
+        UIntArray::class.isPrimitiveArray shouldBe true
+        Array::class.isPrimitiveArray shouldBe false
+
+        // KType isArray
+        typeOf<BooleanArray>().isArray shouldBe true
+        typeOf<UIntArray>().isArray shouldBe true
+        typeOf<Array<Int>>().isArray shouldBe true
+        typeOf<Array<Int?>>().isArray shouldBe true
+        typeOf<Array<*>>().isArray shouldBe true
+
+        // KType isPrimitiveArray
+        typeOf<BooleanArray>().isPrimitiveArray shouldBe true
+        typeOf<UIntArray>().isPrimitiveArray shouldBe true
+        typeOf<Array<Int>>().isPrimitiveArray shouldBe false
+        typeOf<Array<Int?>>().isPrimitiveArray shouldBe false
+        typeOf<Array<*>>().isPrimitiveArray shouldBe false
+
+        // Any isArray
+        booleanArrayOf().isArray shouldBe true
+        uintArrayOf().isArray shouldBe true
+        arrayOf(1).isArray shouldBe true
+        arrayOf(1, null).isArray shouldBe true
+        arrayOfNulls<Any?>(1).isArray shouldBe true
+
+        // Any isPrimitiveArray
+        booleanArrayOf().isPrimitiveArray shouldBe true
+        uintArrayOf().isPrimitiveArray shouldBe true
+        arrayOf(1).isPrimitiveArray shouldBe false
+        arrayOf(1, null).isPrimitiveArray shouldBe false
+        arrayOfNulls<Any?>(1).isPrimitiveArray shouldBe false
+
+        // Any asArrayToList
+        booleanArrayOf(true, false).asArrayAsListOrNull() shouldBe listOf(true, false)
+        uintArrayOf(1u, 2u).asArrayAsListOrNull() shouldBe listOf(1u, 2u)
+        arrayOf(1, 2).asArrayAsListOrNull() shouldBe listOf(1, 2)
+        arrayOf(1, null).asArrayAsListOrNull() shouldBe listOf(1, null)
+        arrayOfNulls<Any?>(1).asArrayAsListOrNull() shouldBe listOf(null)
+        1.asArrayAsListOrNull() shouldBe null
+    }
+
+    @Test
+    fun commonParentsTests() {
+        commonParents(Int::class, Int::class) shouldBe listOf(Int::class)
+        commonParents(Double::class, Int::class) shouldBe listOf(Comparable::class, Number::class)
+        commonParents(Int::class, String::class) shouldBe listOf(Comparable::class, Serializable::class)
+        commonParents(IllegalArgumentException::class, UnsupportedOperationException::class) shouldBe
+            listOf(RuntimeException::class)
+        commonParents(Nothing::class, Nothing::class) shouldBe listOf(Nothing::class)
+        commonParents() shouldBe emptyList()
+        commonParents(List::class, Set::class) shouldBe listOf(Collection::class)
+    }
+
+    @Test
+    fun commonParentTests() {
+        commonParent(Int::class, Int::class) shouldBe Int::class
+        commonParent(Double::class, Int::class) shouldBe Number::class
+        commonParent(Int::class, String::class) shouldBe Comparable::class
+        commonParent(String::class, Int::class) shouldBe Comparable::class
+        commonParent(Nothing::class, Nothing::class) shouldBe Nothing::class
+        commonParent(Int::class, Nothing::class) shouldBe Int::class
+        commonParent() shouldBe null
+        commonParent(List::class, Map::class) shouldBe Any::class
+        commonParent(List::class, Set::class) shouldBe Collection::class
+    }
+
+    @Test
+    fun `createType test`() {
+        emptyList<KClass<*>>().createType(nullable = false) shouldBe nothingType(nullable = false)
+        emptyList<KClass<*>>().createType(nullable = true) shouldBe nothingType(nullable = true)
+
+        listOf(Nothing::class).createType(nullable = false) shouldBe nothingType(nullable = false)
+        listOf(Nothing::class).createType(nullable = true) shouldBe nothingType(nullable = true)
+    }
+
+    @Test
+    fun `commonType classes test`() {
+        emptyList<KClass<*>>().commonType(false, typeOf<List<Int>>()) shouldBe typeOf<List<Int>>()
+        emptyList<KClass<*>>().commonType(true, typeOf<List<Int>>()) shouldBe typeOf<List<Int>?>()
+
+        listOf(Nothing::class).commonType(false) shouldBe nothingType(nullable = false)
+        listOf(Nothing::class).commonType(true) shouldBe nothingType(nullable = true)
+
+        emptyList<KClass<*>>().commonType(false, null) shouldBe nothingType(nullable = false)
+        emptyList<KClass<*>>().commonType(true, null) shouldBe nothingType(nullable = true)
+    }
+
+    val a = listOf(1, 2.0, "a")
+    val b = listOf(1, 2.0, "a", null)
+
+    val c: Int = 1
+
+    @Test
+    fun `guessValueType no listification`() {
+        guessValueType(sequenceOf(1, 2)) shouldBe typeOf<Int>()
+        guessValueType(sequenceOf(1, 2, null)) shouldBe typeOf<Int?>()
+
+        guessValueType(sequenceOf(1, 2.0)) shouldBe typeOf<Number>()
+        guessValueType(sequenceOf(1, 2.0, null)) shouldBe typeOf<Number?>()
+
+        guessValueType(sequenceOf(1, 2.0, "a")) shouldBe typeOf<Comparable<*>>()
+        guessValueType(sequenceOf(1, 2.0, "a", null)) shouldBe typeOf<Comparable<*>?>()
+
+        guessValueType(sequenceOf(1, 2.0, "a", listOf(1, 2))) shouldBe typeOf<Any>()
+        guessValueType(sequenceOf(1, 2.0, "a", null, listOf(1, 2))) shouldBe typeOf<Any?>()
+
+        guessValueType(sequenceOf(null, null)) shouldBe nothingType(nullable = true)
+        guessValueType(emptySequence()) shouldBe nothingType(nullable = false)
+
+        guessValueType(sequenceOf(listOf<Int?>(null))) shouldBe typeOf<List<Nothing?>>()
+        guessValueType(sequenceOf(emptyList<Int>())) shouldBe typeOf<List<Nothing>>()
+        guessValueType(sequenceOf(listOf<Int?>(null), emptyList<Int>())) shouldBe typeOf<List<Nothing?>>()
+        guessValueType(sequenceOf(emptyList<Int>(), null)) shouldBe typeOf<List<Nothing>?>()
+
+        guessValueType(sequenceOf(listOf(1), emptyList())) shouldBe typeOf<List<Int>>()
+        guessValueType(sequenceOf(listOf(1, null), emptyList())) shouldBe typeOf<List<Int?>>()
+        guessValueType(sequenceOf(listOf(1), listOf(null))) shouldBe typeOf<List<Int?>>()
+
+        guessValueType(sequenceOf(1, emptyList<Any?>())) shouldBe typeOf<Any>()
+
+        guessValueType(sequenceOf(1, 2, listOf(1), emptySet<Any>())) shouldBe typeOf<Any>()
+        guessValueType(sequenceOf(listOf(1), setOf(1.0, 2.0))) shouldBe typeOf<Collection<Number>>()
+    }
+
+    @Test
+    fun `guessValueType with listification`() {
+        guessValueType(sequenceOf(1, 2), listifyValues = true) shouldBe typeOf<Int>()
+        guessValueType(sequenceOf(1, 2, null), listifyValues = true) shouldBe typeOf<Int?>()
+
+        guessValueType(sequenceOf(1, 2.0), listifyValues = true) shouldBe typeOf<Number>()
+        guessValueType(sequenceOf(1, 2.0, null), listifyValues = true) shouldBe typeOf<Number?>()
+
+        guessValueType(sequenceOf(1, 2.0, "a"), listifyValues = true) shouldBe typeOf<Comparable<*>>()
+        guessValueType(sequenceOf(1, 2.0, "a", null), listifyValues = true) shouldBe typeOf<Comparable<*>?>()
+
+        guessValueType(sequenceOf(1, 2, listOf(1)), listifyValues = true) shouldBe typeOf<List<Int>>()
+        guessValueType(sequenceOf(1, 2, listOf(1), null), listifyValues = true) shouldBe typeOf<List<Int>>()
+        guessValueType(sequenceOf(1, 2, listOf(1, null)), listifyValues = true) shouldBe typeOf<List<Int?>>()
+        guessValueType(sequenceOf(1, 2, listOf(1, null), null), listifyValues = true) shouldBe typeOf<List<Int?>>()
+
+        guessValueType(sequenceOf(1, 2, listOf(null)), listifyValues = true) shouldBe typeOf<List<Int?>>()
+        guessValueType(sequenceOf(1, 2, listOf(null), null), listifyValues = true) shouldBe typeOf<List<Int?>>()
+
+        guessValueType(sequenceOf(emptyList<Int>()), listifyValues = true) shouldBe typeOf<List<Nothing>>()
+        guessValueType(sequenceOf(emptyList<Int>(), null), listifyValues = true) shouldBe typeOf<List<Nothing>>()
+        guessValueType(sequenceOf(listOf(null)), listifyValues = true) shouldBe typeOf<List<Nothing?>>()
+        guessValueType(sequenceOf(listOf(null), null), listifyValues = true) shouldBe typeOf<List<Nothing?>>()
+
+        guessValueType(
+            values = sequenceOf(1, 2, listOf(1), emptySet<Any>()),
+            listifyValues = true,
+        ) shouldBe typeOf<Any>()
+        guessValueType(
+            values = sequenceOf(1, 2, listOf(1), null, emptySet<Any>()),
+            listifyValues = true,
+        ) shouldBe typeOf<Any?>()
+        guessValueType(
+            values = sequenceOf(1, 2, listOf(1, null), emptySet<Any>()),
+            listifyValues = true,
+        ) shouldBe typeOf<Any>()
+        guessValueType(
+            values = sequenceOf(1, 2, listOf(1, null), null, emptySet<Any>()),
+            listifyValues = true,
+        ) shouldBe typeOf<Any?>()
+
+        guessValueType(
+            values = sequenceOf(1, 2, listOf(null), emptySet<Any>()),
+            listifyValues = true,
+        ) shouldBe typeOf<Any>()
+        guessValueType(
+            values = sequenceOf(1, 2, listOf(null), null, emptySet<Any>()),
+            listifyValues = true,
+        ) shouldBe typeOf<Any?>()
+
+        guessValueType(
+            values = sequenceOf(emptyList(), emptySet<Any>()),
+            listifyValues = true,
+        ) shouldBe typeOf<Collection<Nothing>>()
+        guessValueType(
+            values = sequenceOf(emptyList<Int>(), null, emptySet<Any>()),
+            listifyValues = true,
+        ) shouldBe typeOf<Collection<Nothing>?>()
+        guessValueType(
+            values = sequenceOf(listOf(null), emptySet<Any>()),
+            listifyValues = true,
+        ) shouldBe typeOf<Collection<Nothing?>>()
+        guessValueType(
+            values = sequenceOf(listOf(null), null, emptySet<Any>()),
+            listifyValues = true,
+        ) shouldBe typeOf<Collection<Nothing?>?>()
+    }
+
+    interface UpperBound
+
+    interface TypeWithUpperbound1<T : UpperBound>
+
+    interface TestType1<T : UpperBound> : TypeWithUpperbound1<T>
+
+    interface TestTypeIn1<in T> : Comparable<T>
+
+    interface TestType2<S : UpperBound> : TestTypeIn1<TestType1<S>>
+
+    @Test
+    fun replaceGenericTypeParametersWithUpperbound() {
+        val typeWithUpperboundT = TestType1::class.supertypes.first() // TypeWithUpperbound<T>
+        typeWithUpperboundT.replaceGenericTypeParametersWithUpperbound() shouldBe
+            typeOf<TypeWithUpperbound1<UpperBound>>()
+
+        val comparableTypeT = TestTypeIn1::class.supertypes.first() // Comparable<T>
+        comparableTypeT.replaceGenericTypeParametersWithUpperbound() shouldBe typeOf<Comparable<Nothing>>()
+
+        val nestedTypeWithUpperboundT = TestType2::class.supertypes.first() // TestTypeIn1<TestType1<S>>
+        nestedTypeWithUpperboundT.replaceGenericTypeParametersWithUpperbound() shouldBe
+            typeOf<TestTypeIn1<TestType1<UpperBound>>>()
+    }
+
+    interface AbstractType<T>
+
+    @Test
+    fun `commonType KTypes test`() {
+        // TODO issue #471: Type inference incorrect w.r.t. variance
+        listOf(null).commonType(false) shouldBe typeOf<Any?>()
+//        listOf(null).commonType(true) shouldBe null
+        listOf(typeOf<Int>(), typeOf<Any>()).commonType() shouldBe typeOf<Any>()
+        listOf(typeOf<Int>(), typeOf<List<Any>>()).commonType() shouldBe typeOf<Any>()
+        listOf(typeOf<Int>(), typeOf<List<Any>?>()).commonType() shouldBe typeOf<Any?>()
+        listOf(typeOf<Int>(), typeOf<Int>()).commonType() shouldBe typeOf<Int>()
+        listOf(typeOf<Int>(), typeOf<Int?>()).commonType() shouldBe typeOf<Int?>()
+        listOf(typeOf<Int>(), nothingType(true)).commonType() shouldBe typeOf<Int?>()
+        listOf(typeOf<Int>(), nothingType(false)).commonType() shouldBe typeOf<Int>()
+        listOf(typeOf<Comparable<Int>>(), typeOf<Comparable<Int>>()).commonType() shouldBe typeOf<Comparable<Int>>()
+//        listOf(typeOf<Comparable<Int>>(), typeOf<Comparable<String>>()).commonType() shouldBe typeOf<Comparable<*>>()
+//        listOf(typeOf<List<Int>>(), typeOf<List<String>>()).commonType(false) shouldBe typeOf<List<Comparable<Nothing>>>()
+//        listOf(typeOf<List<Int>>(), typeOf<List<String>>()).commonType() shouldBe typeOf<List<Comparable<*>>>()
+//        listOf(typeOf<List<Int>>(), typeOf<Set<String>>()).commonType(false) shouldBe typeOf<Collection<Comparable<Nothing>>>()
+//        listOf(typeOf<List<Int>>(), typeOf<Set<String>>()).commonType() shouldBe typeOf<Collection<Comparable<*>>>()
+//        listOf(typeOf<List<Int>>(), typeOf<List<List<Any>>>()).commonType() shouldBe typeOf<List<Any>>()
+//        listOf(typeOf<List<Int>>(), typeOf<List<List<Any>?>>()).commonType(false) shouldBe typeOf<List<Any?>>()
+//        listOf(typeOf<List<Int>>(), typeOf<List<List<Any>?>>()).commonType() shouldBe typeOf<List<*>>()
+//        listOf(typeOf<List<Nothing>>(), typeOf<Set<Nothing>>()).commonType() shouldBe typeOf<Collection<Nothing>>()
+        listOf(nothingType(false)).commonType() shouldBe nothingType(false)
+        listOf(nothingType(true)).commonType() shouldBe nothingType(true)
+//        emptyList<KType>().commonType() shouldBe nothingType(false)
+        listOf(
+            typeOf<AbstractType<Int>>(),
+            typeOf<AbstractType<Int>>(),
+        ).commonType() shouldBe typeOf<AbstractType<Int>>()
+//        listOf(typeOf<AbstractType<Int>>(), typeOf<AbstractType<Any>>()).commonType() shouldBe typeOf<AbstractType<out Any>>()
+//        listOf(typeOf<AbstractType<Int>>(), typeOf<AbstractType<in Int>>()).commonType() shouldBe typeOf<AbstractType<in Int>>()
+        listOf(
+            typeOf<AbstractType<in Int>>(),
+            typeOf<AbstractType<in Int>>(),
+        ).commonType() shouldBe typeOf<AbstractType<in Int>>()
+//        listOf(typeOf<AbstractType<Int>>(), typeOf<AbstractType<out Int>>()).commonType() shouldBe typeOf<AbstractType<out Int>>()
+        listOf(
+            typeOf<AbstractType<out Int>>(),
+            typeOf<AbstractType<out Int>>(),
+        ).commonType() shouldBe typeOf<AbstractType<out Int>>()
+//        listOf(typeOf<AbstractType<out Int>>(), typeOf<AbstractType<in Int>>()).commonType(useStar = false) shouldBe typeOf<AbstractType<out Any?>>()
+//        listOf(typeOf<AbstractType<out Int>>(), typeOf<AbstractType<in Int>>()).commonType() shouldBe typeOf<AbstractType<*>>()
+//        listOf(
+//            typeOf<AbstractType<in Int>>(),
+//            typeOf<AbstractType<Any>>()
+//        ).commonType() shouldBe typeOf<AbstractType<in Int>>()
+
+        listOf(typeOf<Int>(), typeOf<List<Any>>()).commonType() shouldBe typeOf<Any>()
+        listOf(typeOf<Int>(), typeOf<List<Any>?>()).commonType() shouldBe typeOf<Any?>()
+        listOf(typeOf<Int>(), typeOf<Int>()).commonType() shouldBe typeOf<Int>()
+        listOf(typeOf<Int>(), typeOf<Int?>()).commonType() shouldBe typeOf<Int?>()
+        listOf(typeOf<Int>(), nothingType(true)).commonType() shouldBe typeOf<Int?>()
+        listOf(typeOf<Int>(), nothingType(false)).commonType() shouldBe typeOf<Int>()
+        listOf(
+            typeOf<List<Int>>(),
+            typeOf<List<String>>(),
+        ).commonType(false) shouldBe typeOf<List<out Comparable<Nothing>>>()
+        listOf(typeOf<List<Int>>(), typeOf<List<String>>()).commonType() shouldBe typeOf<List<out Comparable<*>>>()
+        listOf(
+            typeOf<List<Int>>(),
+            typeOf<Set<String>>(),
+        ).commonType(false) shouldBe typeOf<Collection<out Comparable<Nothing>>>()
+        listOf(typeOf<List<Int>>(), typeOf<Set<String>>()).commonType() shouldBe typeOf<Collection<out Comparable<*>>>()
+        listOf(typeOf<List<Int>>(), typeOf<List<List<Any>>>()).commonType() shouldBe typeOf<List<out Any>>()
+        listOf(typeOf<List<Int>>(), typeOf<List<List<Any>?>>()).commonType(false) shouldBe typeOf<List<out Any?>>()
+        listOf(typeOf<List<Int>>(), typeOf<List<List<Any>?>>()).commonType() shouldBe typeOf<List<*>>()
+        listOf(typeOf<List<Nothing>>(), typeOf<Set<Nothing>>()).commonType() shouldBe typeOf<Collection<out Nothing>>()
+        listOf(nothingType(false)).commonType() shouldBe nothingType(false)
+        listOf(nothingType(true)).commonType() shouldBe nothingType(true)
+        listOf<KType>().commonType() shouldBe typeOf<Any>()
+    }
+
+    @Test
+    fun `commonTypeListifyValues test`() {
+        // TODO issue #471: Type inference incorrect w.r.t. variance
+        listOf<KType>().commonTypeListifyValues() shouldBe typeOf<Any>()
+        listOf(typeOf<Int>(), typeOf<Int>()).commonTypeListifyValues() shouldBe typeOf<Int>()
+        listOf(typeOf<Int>(), typeOf<Int?>()).commonTypeListifyValues() shouldBe typeOf<Int?>()
+        listOf(typeOf<Int>(), nothingType(true)).commonTypeListifyValues() shouldBe typeOf<Int?>()
+        listOf(typeOf<Int>(), nothingType(false)).commonTypeListifyValues() shouldBe typeOf<Int>()
+        listOf(typeOf<Int>(), typeOf<Double>(), nothingType(true)).commonTypeListifyValues() shouldBe typeOf<Number?>()
+        listOf(
+            typeOf<List<Int>>(),
+            typeOf<List<String>>(),
+        ).commonTypeListifyValues() shouldBe typeOf<List<out Comparable<*>>>()
+        listOf(
+            typeOf<List<Int>>(),
+            typeOf<Set<String>>(),
+        ).commonTypeListifyValues() shouldBe typeOf<Collection<out Comparable<*>>>()
+
+        listOf(
+            typeOf<Int>(),
+            typeOf<List<Int>>(),
+        ).commonTypeListifyValues() shouldBe typeOf<List<Int>>()
+
+        listOf(
+            typeOf<Int>(),
+            typeOf<List<Int>>(),
+            nothingType(true),
+        ).commonTypeListifyValues() shouldBe typeOf<List<Int>>()
+
+        listOf(
+            typeOf<Int>(),
+            typeOf<List<Int?>>(),
+            nothingType(true),
+        ).commonTypeListifyValues() shouldBe typeOf<List<Int?>>()
+
+        listOf(
+            typeOf<List<Nothing>>(),
+            typeOf<List<Nothing>>(),
+        ).commonTypeListifyValues() shouldBe typeOf<List<Nothing>>()
+
+        listOf(
+            typeOf<List<Nothing>>(),
+            nothingType(true),
+        ).commonTypeListifyValues() shouldBe typeOf<List<Nothing>>()
+
+        listOf(
+            typeOf<Int>(),
+            typeOf<List<Int>>(),
+            typeOf<Set<Any>>(),
+        ).commonTypeListifyValues() shouldBe typeOf<Any>()
+
+        listOf(
+            typeOf<Int>(),
+            typeOf<List<Int>>(),
+            typeOf<Set<Any>>(),
+            nothingType(true),
+        ).commonTypeListifyValues() shouldBe typeOf<Any?>()
+
+        listOf(
+            typeOf<List<Nothing>>(),
+            typeOf<Set<Nothing>>(),
+        ).commonTypeListifyValues() shouldBe typeOf<Collection<out Nothing>>()
+
+        listOf(
+            typeOf<List<Nothing>>(),
+            typeOf<Set<Nothing>>(),
+            nothingType(true),
+        ).commonTypeListifyValues() shouldBe typeOf<Collection<out Nothing>?>()
+
+        listOf(
+            typeOf<List<Nothing?>>(),
+            typeOf<Set<Nothing>>(),
+        ).commonTypeListifyValues() shouldBe typeOf<Collection<out Nothing?>>()
+
+        listOf(
+            typeOf<List<Nothing?>>(),
+            typeOf<Set<Nothing>?>(),
+        ).commonTypeListifyValues() shouldBe typeOf<Collection<out Nothing?>?>()
+    }
+}
diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/annotations/ImportDataSchema.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/annotations/ImportDataSchema.kt
index 87ea52ca9..ded7a366e 100644
--- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/annotations/ImportDataSchema.kt
+++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/annotations/ImportDataSchema.kt
@@ -47,6 +47,7 @@ public enum class DataSchemaVisibility {
     EXPLICIT_PUBLIC,
 }
 
+// TODO add more options
 public annotation class CsvOptions(public val delimiter: Char)
 
 /**
diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/utils.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/utils.kt
index c17fcd610..0377567a8 100644
--- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/utils.kt
+++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/utils.kt
@@ -19,24 +19,31 @@ import kotlin.annotation.AnnotationTarget.VALUE_PARAMETER
  * {@include [Indent]}
  *
  */
+@ExcludeFromSources
 internal interface LineBreak
 
 /** &nbsp; */
+@ExcludeFromSources
 internal interface QuarterIndent
 
 /** &nbsp;&nbsp; */
+@ExcludeFromSources
 internal interface HalfIndent
 
 /** &nbsp;&nbsp;&nbsp;&nbsp; */
+@ExcludeFromSources
 internal interface Indent
 
 /** &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; */
+@ExcludeFromSources
 internal interface DoubleIndent
 
 /** &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; */
+@ExcludeFromSources
 internal interface TripleIndent
 
 /** &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; */
+@ExcludeFromSources
 internal interface QuadrupleIndent
 
 /**
diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/io/DoubleParser.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/io/DoubleParser.kt
index bc725201b..8008e4b81 100644
--- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/io/DoubleParser.kt
+++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/io/DoubleParser.kt
@@ -17,8 +17,8 @@ private val logger = KotlinLogging.logger {}
 /**
  * Parses a [String]/[CharSequence], [CharArray], or [ByteArray] into a [Double].
  *
- * If [ParserOptions.useFastDoubleParser] is enabled, it will try to parse the input with a fast double parser,
- * [ConfigurableDoubleParser].
+ * If [ParserOptions.useFastDoubleParser] is enabled, it will try to parse the input with an _EXPERIMENTAL_
+ * fast double parser, [ConfigurableDoubleParser].
  * We use [ConfigurableDoubleParser] instead of the, even faster, [JavaDoubleParser] to
  * support different locales and fallback symbols.
  *
diff --git a/dataframe-csv/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/CommonReadDelimDocs.kt b/dataframe-csv/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/CommonReadDelimDocs.kt
index 0bc9e6ae2..b386c0170 100644
--- a/dataframe-csv/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/CommonReadDelimDocs.kt
+++ b/dataframe-csv/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/CommonReadDelimDocs.kt
@@ -1,3 +1,5 @@
+@file:ExcludeFromSources
+
 package org.jetbrains.kotlinx.dataframe.documentation
 
 import org.jetbrains.kotlinx.dataframe.DataFrame
diff --git a/dataframe-csv/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/utils.kt b/dataframe-csv/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/utils.kt
index 3834c15d7..0377567a8 100644
--- a/dataframe-csv/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/utils.kt
+++ b/dataframe-csv/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/utils.kt
@@ -1,5 +1,3 @@
-@file:ExcludeFromSources
-
 package org.jetbrains.kotlinx.dataframe.documentation
 
 import kotlin.annotation.AnnotationTarget.ANNOTATION_CLASS
@@ -21,24 +19,31 @@ import kotlin.annotation.AnnotationTarget.VALUE_PARAMETER
  * {@include [Indent]}
  *
  */
+@ExcludeFromSources
 internal interface LineBreak
 
 /** &nbsp; */
+@ExcludeFromSources
 internal interface QuarterIndent
 
 /** &nbsp;&nbsp; */
+@ExcludeFromSources
 internal interface HalfIndent
 
 /** &nbsp;&nbsp;&nbsp;&nbsp; */
+@ExcludeFromSources
 internal interface Indent
 
 /** &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; */
+@ExcludeFromSources
 internal interface DoubleIndent
 
 /** &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; */
+@ExcludeFromSources
 internal interface TripleIndent
 
 /** &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; */
+@ExcludeFromSources
 internal interface QuadrupleIndent
 
 /**
diff --git a/dataframe-csv/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/io/FastDoubleParser.kt b/dataframe-csv/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/io/DataFrameCustomDoubleParser.kt
similarity index 90%
rename from dataframe-csv/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/io/FastDoubleParser.kt
rename to dataframe-csv/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/io/DataFrameCustomDoubleParser.kt
index d4c403323..28695d7c3 100644
--- a/dataframe-csv/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/io/FastDoubleParser.kt
+++ b/dataframe-csv/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/io/DataFrameCustomDoubleParser.kt
@@ -7,7 +7,7 @@ import org.jetbrains.kotlinx.dataframe.api.ParserOptions
 /**
  * Wrapper around [DoubleParser] so we can use it from Deephaven.
  */
-internal class FastDoubleParser(parserOptions: ParserOptions) : CustomDoubleParser {
+internal class DataFrameCustomDoubleParser(parserOptions: ParserOptions) : CustomDoubleParser {
 
     private val doubleParser = DoubleParser(parserOptions)
 
diff --git a/dataframe-csv/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/io/ListSink.kt b/dataframe-csv/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/io/ListSink.kt
index 4ad3b64ad..eee712c03 100644
--- a/dataframe-csv/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/io/ListSink.kt
+++ b/dataframe-csv/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/io/ListSink.kt
@@ -34,35 +34,23 @@ internal interface SinkSource<T : Any> :
 @Suppress("UNCHECKED_CAST")
 internal class ListSink(val columnIndex: Int, val dataType: DataType) : SinkSource<Any> {
 
+    @Suppress("ktlint:standard:comment-wrapping", "ktlint:standard:no-consecutive-comments")
     companion object {
         val SINK_FACTORY: SinkFactory = SinkFactory.of(
-            // byteSinkSupplier =
-            { ListSink(it, BYTE) as SinkSource<ByteArray> }, // unused in Parsers.DEFAULT
-            // shortSinkSupplier =
-            { ListSink(it, SHORT) as SinkSource<ShortArray> }, // unused in Parsers.DEFAULT
-            // intSinkSupplier =
-            { ListSink(it, INT) as SinkSource<IntArray> },
-            // longSinkSupplier =
-            { ListSink(it, LONG) as SinkSource<LongArray> },
-            // floatSinkSupplier =
-            { ListSink(it, FLOAT) as SinkSource<FloatArray> }, // unused in Parsers.COMPLETE and Parsers.DEFAULT
-            // doubleSinkSupplier =
-            { ListSink(it, DOUBLE) as SinkSource<DoubleArray> },
-            // booleanAsByteSinkSupplier =
-            { ListSink(it, BOOLEAN_AS_BYTE) as SinkSource<ByteArray> },
-            // charSinkSupplier =
-            { ListSink(it, CHAR) as SinkSource<CharArray> },
-            // stringSinkSupplier =
-            { ListSink(it, STRING) as SinkSource<Array<String>> },
-            // dateTimeAsLongSinkSupplier =
-            { ListSink(it, DATETIME_AS_LONG) as SinkSource<LongArray> },
-            // timestampAsLongSinkSupplier =
-            {
-                ListSink(
-                    it,
-                    TIMESTAMP_AS_LONG,
-                ) as SinkSource<LongArray>
-            }, // unused in Parsers.COMPLETE and Parsers.DEFAULT
+            // unused in Parsers.DEFAULT:
+            /* byteSinkSupplier = */ { ListSink(it, BYTE) as SinkSource<ByteArray> },
+            /* shortSinkSupplier = */ { ListSink(it, SHORT) as SinkSource<ShortArray> },
+            /* intSinkSupplier = */ { ListSink(it, INT) as SinkSource<IntArray> },
+            /* longSinkSupplier = */ { ListSink(it, LONG) as SinkSource<LongArray> },
+            // unused in Parsers.COMPLETE and Parsers.DEFAULT:
+            /* floatSinkSupplier = */ { ListSink(it, FLOAT) as SinkSource<FloatArray> },
+            /* doubleSinkSupplier = */ { ListSink(it, DOUBLE) as SinkSource<DoubleArray> },
+            /* booleanAsByteSinkSupplier = */ { ListSink(it, BOOLEAN_AS_BYTE) as SinkSource<ByteArray> },
+            /* charSinkSupplier = */ { ListSink(it, CHAR) as SinkSource<CharArray> },
+            /* stringSinkSupplier = */ { ListSink(it, STRING) as SinkSource<Array<String>> },
+            /* dateTimeAsLongSinkSupplier = */ { ListSink(it, DATETIME_AS_LONG) as SinkSource<LongArray> },
+            // unused in Parsers.COMPLETE and Parsers.DEFAULT:
+            /* timestampAsLongSinkSupplier = */ { ListSink(it, TIMESTAMP_AS_LONG) as SinkSource<LongArray> },
         )
     }
 
diff --git a/dataframe-csv/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/io/ioUtils.kt b/dataframe-csv/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/io/ioUtils.kt
index 27e827fb3..58764ff3c 100644
--- a/dataframe-csv/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/io/ioUtils.kt
+++ b/dataframe-csv/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/io/ioUtils.kt
@@ -50,7 +50,7 @@ internal fun catchHttpResponse(url: URL, body: (InputStream) -> AnyFrame): AnyFr
     }
 }
 
-public fun asURL(fileOrUrl: String): URL =
+public fun asUrl(fileOrUrl: String): URL =
     if (isURL(fileOrUrl)) {
         URL(fileOrUrl).toURI()
     } else {
@@ -70,17 +70,17 @@ internal inline fun <T, I : InputStream> InputStream.useSafely(
     compression: Compression<I>,
     block: (InputStream) -> T,
 ): T {
-    // first wrap the stream in the compression algorithm
-    val unpackedStream = compression(this)
-    compression.doFirst(unpackedStream)
+    // first wrap the stream by (optional) compression algorithm
+    val wrappedStream = compression.wrapStream(this)
+    compression.doFirst(wrappedStream)
 
     val bomSafeStream = BOMInputStream.builder()
-        .setInputStream(unpackedStream)
+        .setInputStream(wrappedStream)
         .get()
 
     try {
         return block(bomSafeStream)
     } finally {
-        compression.doFinally(unpackedStream)
+        compression.doFinally(wrappedStream)
     }
 }
diff --git a/dataframe-csv/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/io/readDelim.kt b/dataframe-csv/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/io/readDelim.kt
index 8a6a788ff..4c75f7dcd 100644
--- a/dataframe-csv/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/io/readDelim.kt
+++ b/dataframe-csv/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/io/readDelim.kt
@@ -27,6 +27,7 @@ import org.jetbrains.kotlinx.dataframe.DataRow
 import org.jetbrains.kotlinx.dataframe.api.ParserOptions
 import org.jetbrains.kotlinx.dataframe.api.dataFrameOf
 import org.jetbrains.kotlinx.dataframe.api.parse
+import org.jetbrains.kotlinx.dataframe.api.toDataFrame
 import org.jetbrains.kotlinx.dataframe.api.tryParse
 import org.jetbrains.kotlinx.dataframe.columns.ValueColumn
 import org.jetbrains.kotlinx.dataframe.documentation.DelimParams.ADDITIONAL_CSV_SPECS
@@ -58,6 +59,7 @@ import kotlin.reflect.typeOf
 import kotlin.time.Duration
 
 /**
+ * Implementation to read delimiter-separated data from an [InputStream] based on the Deephaven CSV library.
  *
  * @include [INPUT_STREAM_READ]
  * @param delimiter The field delimiter character. The default is ',' for CSV, '\t' for TSV.
@@ -97,7 +99,7 @@ internal fun readDelimImpl(
     // set up the csv specs
     val csvSpecs = with(CsvSpecs.builder()) {
         if (additionalCsvSpecs != null) from(additionalCsvSpecs)
-        customDoubleParser(FastDoubleParser(parserOptions))
+        customDoubleParser(DataFrameCustomDoubleParser(parserOptions))
         nullValueLiterals(parserOptions.nullStrings ?: DEFAULT_NULL_STRINGS)
         headerLegalizer(::legalizeHeader)
         numRows(readLines ?: Long.MAX_VALUE)
@@ -109,9 +111,7 @@ internal fun readDelimImpl(
         ignoreSurroundingSpaces(ignoreSurroundingSpaces)
         trim(trimInsideQuoted)
         concurrent(parseParallel)
-
         header(header)
-
         skipLines(takeHeaderFromCsv = header.isEmpty(), skipLines = skipLines)
 
         val useDeepHavenLocalDateTime = with(parserOptions) {
@@ -119,32 +119,33 @@ internal fun readDelimImpl(
         }
         parsersWithOptions(parserOptions, useDeepHavenLocalDateTime)
 
-        colTypes(colTypes, useDeepHavenLocalDateTime) // this function must be last, so the return value is used
+        // this function must be last, so the return value is used
+        return@with this.withColTypes(colTypes, useDeepHavenLocalDateTime)
     }.build()
 
     val csvReaderResult = inputStream.useSafely(compression) { safeInputStream ->
+        // check if the input stream is empty, return either empty df or df with supplied header
         if (safeInputStream.available() <= 0) {
-            return if (header.isEmpty()) {
+            return@readDelimImpl if (header.isEmpty()) {
                 DataFrame.empty()
             } else {
-                dataFrameOf(
-                    header.map {
-                        DataColumn.createValueColumn(
-                            name = it,
-                            values = emptyList<String>(),
-                            type = typeOf<String>(),
-                        )
-                    },
-                )
+                header.map {
+                    DataColumn.createValueColumn(
+                        name = it,
+                        values = emptyList<String>(),
+                        type = typeOf<String>(),
+                    )
+                }.toDataFrame()
             }
         }
 
         // read the csv
         try {
+            @Suppress("ktlint:standard:comment-wrapping")
             CsvReader.read(
-                csvSpecs,
-                safeInputStream,
-                ListSink.SINK_FACTORY,
+                /* specs = */ csvSpecs,
+                /* stream = */ safeInputStream,
+                /* sinkFactory = */ ListSink.SINK_FACTORY,
             )
         } catch (e: CsvReaderException) {
             throw IllegalStateException("Could not read delimiter-separated data", e)
@@ -170,7 +171,7 @@ private fun CsvReader.ResultColumn.toDataColumn(
     desiredColType: ColType?,
 ): DataColumn<*> {
     val listSink = data()!! as ListSink
-    val columnData: List<Any?> = listSink.data
+    val columnData = listSink.data
     val dataType = listSink.dataType
     val hasNulls = listSink.hasNulls
     val type = dataType().toKType().withNullability(hasNulls)
@@ -182,7 +183,7 @@ private fun CsvReader.ResultColumn.toDataColumn(
     )
     if (dataType != STRING) return column
 
-    // perform additional parsing if necessary
+    // attempt to perform additional parsing if necessary, will remain String if it fails
     column as ValueColumn<String?>
 
     return if (desiredColType == null) {
@@ -192,6 +193,7 @@ private fun CsvReader.ResultColumn.toDataColumn(
         )
         column.tryParse(adjustedParserOptions)
     } else {
+        // try parsing only with the desired type
         column.tryParse(
             parserOptions.copy(
                 skipTypes = ParserOptions.allTypesExcept(desiredColType.toKType()),
@@ -244,14 +246,14 @@ private fun legalizeHeader(header: Array<String>): Array<String> {
  * CAREFUL: Unlike the other functions on [CsvSpecs.Builder], this function can return a NEW builder instance.
  * Make sure to use the return value.
  */
-private fun CsvSpecs.Builder.colTypes(
+private fun CsvSpecs.Builder.withColTypes(
     colTypes: Map<String, ColType>,
     useDeepHavenLocalDateTime: Boolean,
 ): CsvSpecs.Builder {
     if (colTypes.isEmpty()) return this
 
-    colTypes.entries.fold(this) { it, (colName, colType) ->
-        it.putParserForName(colName, colType.toCsvParser(useDeepHavenLocalDateTime))
+    colTypes.forEach { (colName, colType) ->
+        this.putParserForName(colName, colType.toCsvParser(useDeepHavenLocalDateTime))
     }
 
     return if (DEFAULT_COL_TYPE in colTypes) {
@@ -280,12 +282,9 @@ private fun CsvSpecs.Builder.parsersWithOptions(
     if (parserOptions.skipTypes.isEmpty()) {
         parsers(Parsers.DEFAULT) // BOOLEAN, INT, LONG, DOUBLE, DATETIME, CHAR, STRING
     } else {
-        parsers(
-            Parsers.DEFAULT.toSet() -
-                parserOptions.skipTypes
-                    .mapNotNull { it.toColType().toCsvParserOrNull(useDeepHavenLocalDateTime) }
-                    .toSet(),
-        )
+        val parsersToSkip = parserOptions.skipTypes
+            .mapNotNull { it.toColType().toCsvParserOrNull(useDeepHavenLocalDateTime) }
+        parsers(Parsers.DEFAULT.toSet() - parsersToSkip.toSet())
     }
 
 private fun CsvSpecs.Builder.header(header: List<String>): CsvSpecs.Builder =
@@ -297,6 +296,10 @@ private fun CsvSpecs.Builder.header(header: List<String>): CsvSpecs.Builder =
             .headers(header)
     }
 
+/**
+ * Converts a [ColType] to a [Parser] from the Deephaven CSV library.
+ * If no direct [Parser] exists, it returns `null`.
+ */
 internal fun ColType.toCsvParserOrNull(useDeepHavenLocalDateTime: Boolean): Parser<*>? =
     when (this) {
         ColType.Int -> Parsers.INT
@@ -359,6 +362,8 @@ internal fun KType.toColType(): ColType =
 /**
  * Types that Deephaven already parses, so we can skip them when
  * defaulting to DataFrame's String parsers.
+ *
+ * [LocalDateTime] and [java.time.LocalDateTime] are not included because Deephaven cannot recognize all formats.
  */
 internal val typesDeephavenAlreadyParses: Set<KType> =
     setOf(
@@ -367,6 +372,4 @@ internal val typesDeephavenAlreadyParses: Set<KType> =
         typeOf<Double>(),
         typeOf<Char>(),
         typeOf<Boolean>(),
-//        typeOf<LocalDateTime>(), it cannot recognize all formats
-//        typeOf<java.time.LocalDateTime>(), it cannot recognize all formats
     )
diff --git a/dataframe-csv/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/io/writeDelim.kt b/dataframe-csv/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/io/writeDelim.kt
index f1e398c9e..442594701 100644
--- a/dataframe-csv/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/io/writeDelim.kt
+++ b/dataframe-csv/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/io/writeDelim.kt
@@ -4,18 +4,30 @@ import org.apache.commons.csv.CSVFormat
 import org.jetbrains.kotlinx.dataframe.AnyFrame
 import org.jetbrains.kotlinx.dataframe.AnyRow
 import org.jetbrains.kotlinx.dataframe.api.forEach
+import org.jetbrains.kotlinx.dataframe.documentation.CommonWriteDelimDocs
 import org.jetbrains.kotlinx.dataframe.documentation.DelimParams.ADDITIONAL_CSV_FORMAT
 import org.jetbrains.kotlinx.dataframe.documentation.DelimParams.COMMENT_CHAR
+import org.jetbrains.kotlinx.dataframe.documentation.DelimParams.CSV_DELIMITER
 import org.jetbrains.kotlinx.dataframe.documentation.DelimParams.ESCAPE_CHAR
 import org.jetbrains.kotlinx.dataframe.documentation.DelimParams.HEADER_COMMENTS
 import org.jetbrains.kotlinx.dataframe.documentation.DelimParams.INCLUDE_HEADER
 import org.jetbrains.kotlinx.dataframe.documentation.DelimParams.QUOTE
 import org.jetbrains.kotlinx.dataframe.documentation.DelimParams.QUOTE_MODE
 import org.jetbrains.kotlinx.dataframe.documentation.DelimParams.RECORD_SEPARATOR
+import org.jetbrains.kotlinx.dataframe.documentation.DelimParams.WRITER_WRITE
 import org.jetbrains.kotlinx.dataframe.io.QuoteMode
 import org.jetbrains.kotlinx.dataframe.io.toJson
 import org.apache.commons.csv.QuoteMode as ApacheQuoteMode
 
+/**
+ * Writes [df] to [writer] in a delimiter-separated format.
+ *
+ * @param df The data to write.
+ * @include [WRITER_WRITE]
+ * @include [CSV_DELIMITER]
+ * @include [CommonWriteDelimDocs.CommonWriteParams]
+ * @include [ADDITIONAL_CSV_FORMAT]
+ */
 internal fun writeDelimImpl(
     df: AnyFrame,
     writer: Appendable,
@@ -29,6 +41,7 @@ internal fun writeDelimImpl(
     recordSeparator: String = RECORD_SEPARATOR,
     additionalCsvFormat: CSVFormat = ADDITIONAL_CSV_FORMAT,
 ) {
+    // setup CSV format
     val format = with(CSVFormat.Builder.create(additionalCsvFormat)) {
         setDelimiter(delimiter)
         setQuote(quote)
@@ -40,6 +53,7 @@ internal fun writeDelimImpl(
         setHeaderComments(*headerComments.toTypedArray())
     }.build()
 
+    // let the format handle the writing, only converting AnyRow and AnyFrame to JSON
     format.print(writer).use { printer ->
         if (includeHeader) {
             printer.printRecord(df.columnNames())
diff --git a/dataframe-csv/src/main/kotlin/org/jetbrains/kotlinx/dataframe/io/Compression.kt b/dataframe-csv/src/main/kotlin/org/jetbrains/kotlinx/dataframe/io/Compression.kt
index 9a177d091..7ed953f82 100644
--- a/dataframe-csv/src/main/kotlin/org/jetbrains/kotlinx/dataframe/io/Compression.kt
+++ b/dataframe-csv/src/main/kotlin/org/jetbrains/kotlinx/dataframe/io/Compression.kt
@@ -7,14 +7,13 @@ import java.util.zip.ZipInputStream
 
 /**
  * Compression algorithm to use when reading csv files.
- * We support GZIP and ZIP compression out of the box.
+ * We support [GZIP][Compression.Gzip] and [ZIP][Compression.Zip] compression out of the box.
  *
  * Custom decompression algorithms can be added by creating an instance of [Custom].
  *
  * @param wrapStream function that wraps any [InputStream] into a decompressing [InflaterInputStream] stream
  */
-public sealed class Compression<I : InputStream>(public open val wrapStream: (InputStream) -> I) :
-    (InputStream) -> I by wrapStream {
+public sealed class Compression<I : InputStream>(public open val wrapStream: (InputStream) -> I) {
 
     /** Can be overridden to perform some actions before reading from the input stream. */
     public open fun doFirst(inputStream: I) {}
@@ -30,16 +29,14 @@ public sealed class Compression<I : InputStream>(public open val wrapStream: (In
     /**
      * For .gz / GZIP files.
      */
-    public data object Gzip : Compression<GZIPInputStream>(::GZIPInputStream)
+    public data object Gzip : Compression<GZIPInputStream>(wrapStream = ::GZIPInputStream)
 
     /**
      * For .zip / ZIP files.
      */
-    public data object Zip : Compression<ZipInputStream>(::ZipInputStream) {
+    public data object Zip : Compression<ZipInputStream>(wrapStream = ::ZipInputStream) {
 
         override fun doFirst(inputStream: ZipInputStream) {
-            super.doFirst(inputStream)
-
             // Make sure to call nextEntry once to prepare the stream
             if (inputStream.nextEntry == null) error("No entries in zip file")
         }
@@ -57,12 +54,12 @@ public sealed class Compression<I : InputStream>(public open val wrapStream: (In
     /**
      * No compression.
      */
-    public data object None : Compression<InputStream>({ it })
+    public data object None : Compression<InputStream>(wrapStream = { it })
 
     /**
      * Custom decompression algorithm.
      * @param wrapStream function that wraps any [InputStream] into a decompressing [InflaterInputStream] stream
      */
     public data class Custom<I : InflaterInputStream>(override val wrapStream: (InputStream) -> I) :
-        Compression<I>(wrapStream)
+        Compression<I>(wrapStream = wrapStream)
 }
diff --git a/dataframe-csv/src/main/kotlin/org/jetbrains/kotlinx/dataframe/io/readCsv.kt b/dataframe-csv/src/main/kotlin/org/jetbrains/kotlinx/dataframe/io/readCsv.kt
index fec7561fa..d3f8b250c 100644
--- a/dataframe-csv/src/main/kotlin/org/jetbrains/kotlinx/dataframe/io/readCsv.kt
+++ b/dataframe-csv/src/main/kotlin/org/jetbrains/kotlinx/dataframe/io/readCsv.kt
@@ -25,7 +25,7 @@ import org.jetbrains.kotlinx.dataframe.documentation.DelimParams.QUOTE
 import org.jetbrains.kotlinx.dataframe.documentation.DelimParams.READ_LINES
 import org.jetbrains.kotlinx.dataframe.documentation.DelimParams.SKIP_LINES
 import org.jetbrains.kotlinx.dataframe.documentation.DelimParams.TRIM_INSIDE_QUOTED
-import org.jetbrains.kotlinx.dataframe.impl.io.asURL
+import org.jetbrains.kotlinx.dataframe.impl.io.asUrl
 import org.jetbrains.kotlinx.dataframe.impl.io.catchHttpResponse
 import org.jetbrains.kotlinx.dataframe.impl.io.compressionStateOf
 import org.jetbrains.kotlinx.dataframe.impl.io.readDelimImpl
@@ -155,7 +155,7 @@ public fun DataFrame.Companion.readCsv(
     trimInsideQuoted: Boolean = TRIM_INSIDE_QUOTED,
     parseParallel: Boolean = PARSE_PARALLEL,
 ): DataFrame<*> =
-    catchHttpResponse(asURL(fileOrUrl = fileOrUrl)) {
+    catchHttpResponse(asUrl(fileOrUrl = fileOrUrl)) {
         readDelimImpl(
             inputStream = it,
             delimiter = delimiter,
diff --git a/dataframe-csv/src/main/kotlin/org/jetbrains/kotlinx/dataframe/io/readDelim.kt b/dataframe-csv/src/main/kotlin/org/jetbrains/kotlinx/dataframe/io/readDelim.kt
index 78d307e31..8541b83a3 100644
--- a/dataframe-csv/src/main/kotlin/org/jetbrains/kotlinx/dataframe/io/readDelim.kt
+++ b/dataframe-csv/src/main/kotlin/org/jetbrains/kotlinx/dataframe/io/readDelim.kt
@@ -25,7 +25,7 @@ import org.jetbrains.kotlinx.dataframe.documentation.DelimParams.QUOTE
 import org.jetbrains.kotlinx.dataframe.documentation.DelimParams.READ_LINES
 import org.jetbrains.kotlinx.dataframe.documentation.DelimParams.SKIP_LINES
 import org.jetbrains.kotlinx.dataframe.documentation.DelimParams.TRIM_INSIDE_QUOTED
-import org.jetbrains.kotlinx.dataframe.impl.io.asURL
+import org.jetbrains.kotlinx.dataframe.impl.io.asUrl
 import org.jetbrains.kotlinx.dataframe.impl.io.catchHttpResponse
 import org.jetbrains.kotlinx.dataframe.impl.io.compressionStateOf
 import org.jetbrains.kotlinx.dataframe.impl.io.readDelimImpl
@@ -161,7 +161,7 @@ public fun DataFrame.Companion.readDelim(
     trimInsideQuoted: Boolean = TRIM_INSIDE_QUOTED,
     parseParallel: Boolean = PARSE_PARALLEL,
 ): DataFrame<*> =
-    catchHttpResponse(asURL(fileOrUrl = fileOrUrl)) {
+    catchHttpResponse(asUrl(fileOrUrl = fileOrUrl)) {
         readDelimImpl(
             inputStream = it,
             delimiter = delimiter,
diff --git a/dataframe-csv/src/main/kotlin/org/jetbrains/kotlinx/dataframe/io/readTsv.kt b/dataframe-csv/src/main/kotlin/org/jetbrains/kotlinx/dataframe/io/readTsv.kt
index af459d730..fa550a604 100644
--- a/dataframe-csv/src/main/kotlin/org/jetbrains/kotlinx/dataframe/io/readTsv.kt
+++ b/dataframe-csv/src/main/kotlin/org/jetbrains/kotlinx/dataframe/io/readTsv.kt
@@ -25,7 +25,7 @@ import org.jetbrains.kotlinx.dataframe.documentation.DelimParams.READ_LINES
 import org.jetbrains.kotlinx.dataframe.documentation.DelimParams.SKIP_LINES
 import org.jetbrains.kotlinx.dataframe.documentation.DelimParams.TRIM_INSIDE_QUOTED
 import org.jetbrains.kotlinx.dataframe.documentation.DelimParams.TSV_DELIMITER
-import org.jetbrains.kotlinx.dataframe.impl.io.asURL
+import org.jetbrains.kotlinx.dataframe.impl.io.asUrl
 import org.jetbrains.kotlinx.dataframe.impl.io.catchHttpResponse
 import org.jetbrains.kotlinx.dataframe.impl.io.compressionStateOf
 import org.jetbrains.kotlinx.dataframe.impl.io.readDelimImpl
@@ -155,7 +155,7 @@ public fun DataFrame.Companion.readTsv(
     trimInsideQuoted: Boolean = TRIM_INSIDE_QUOTED,
     parseParallel: Boolean = PARSE_PARALLEL,
 ): DataFrame<*> =
-    catchHttpResponse(asURL(fileOrUrl = fileOrUrl)) {
+    catchHttpResponse(asUrl(fileOrUrl = fileOrUrl)) {
         readDelimImpl(
             inputStream = it,
             delimiter = delimiter,
diff --git a/dataframe-csv/src/test/kotlin/org/jetbrains/kotlinx/dataframe/io/DelimCsvTsvTests.kt b/dataframe-csv/src/test/kotlin/org/jetbrains/kotlinx/dataframe/io/DelimCsvTsvTests.kt
index fe6a06b8d..78ea0f32f 100644
--- a/dataframe-csv/src/test/kotlin/org/jetbrains/kotlinx/dataframe/io/DelimCsvTsvTests.kt
+++ b/dataframe-csv/src/test/kotlin/org/jetbrains/kotlinx/dataframe/io/DelimCsvTsvTests.kt
@@ -4,7 +4,6 @@ import io.kotest.assertions.throwables.shouldNotThrowAny
 import io.kotest.assertions.throwables.shouldThrow
 import io.kotest.matchers.nulls.shouldNotBeNull
 import io.kotest.matchers.shouldBe
-import jdk.nashorn.internal.ir.annotations.Ignore
 import kotlinx.datetime.LocalDate
 import kotlinx.datetime.LocalDateTime
 import org.intellij.lang.annotations.Language
@@ -19,6 +18,7 @@ import org.jetbrains.kotlinx.dataframe.api.isEmpty
 import org.jetbrains.kotlinx.dataframe.api.print
 import org.jetbrains.kotlinx.dataframe.api.schema
 import org.jetbrains.kotlinx.dataframe.api.toStr
+import org.junit.Ignore
 import org.junit.Test
 import java.io.File
 import java.io.StringWriter
diff --git a/plugins/dataframe-gradle-plugin/src/main/kotlin/org/jetbrains/dataframe/gradle/GenerateDataSchemaTask.kt b/plugins/dataframe-gradle-plugin/src/main/kotlin/org/jetbrains/dataframe/gradle/GenerateDataSchemaTask.kt
index 5cc6f14dc..8f6873079 100644
--- a/plugins/dataframe-gradle-plugin/src/main/kotlin/org/jetbrains/dataframe/gradle/GenerateDataSchemaTask.kt
+++ b/plugins/dataframe-gradle-plugin/src/main/kotlin/org/jetbrains/dataframe/gradle/GenerateDataSchemaTask.kt
@@ -116,6 +116,7 @@ abstract class GenerateDataSchemaTask : DefaultTask() {
             val url = urlOf(data.get())
 
             val formats = listOf(
+                // TODO new Csv() and Tsv()
                 CSV(delimiter = csvOptions.delimiter),
                 JSON(typeClashTactic = jsonOptions.typeClashTactic, keyValuePaths = jsonOptions.keyValuePaths),
                 Excel(),
diff --git a/plugins/dataframe-gradle-plugin/src/main/kotlin/org/jetbrains/dataframe/gradle/SchemaGeneratorExtension.kt b/plugins/dataframe-gradle-plugin/src/main/kotlin/org/jetbrains/dataframe/gradle/SchemaGeneratorExtension.kt
index ecafd13b2..b9f3dc9c5 100644
--- a/plugins/dataframe-gradle-plugin/src/main/kotlin/org/jetbrains/dataframe/gradle/SchemaGeneratorExtension.kt
+++ b/plugins/dataframe-gradle-plugin/src/main/kotlin/org/jetbrains/dataframe/gradle/SchemaGeneratorExtension.kt
@@ -123,6 +123,7 @@ class Schema(
 }
 
 // Without Serializable GradleRunner tests fail
+// TODO add more options
 data class CsvOptionsDsl(var delimiter: Char = ',') : Serializable
 
 data class JsonOptionsDsl(
diff --git a/plugins/symbol-processor/src/main/kotlin/org/jetbrains/dataframe/ksp/DataSchemaGenerator.kt b/plugins/symbol-processor/src/main/kotlin/org/jetbrains/dataframe/ksp/DataSchemaGenerator.kt
index e4ce34381..9f4a84470 100644
--- a/plugins/symbol-processor/src/main/kotlin/org/jetbrains/dataframe/ksp/DataSchemaGenerator.kt
+++ b/plugins/symbol-processor/src/main/kotlin/org/jetbrains/dataframe/ksp/DataSchemaGenerator.kt
@@ -155,6 +155,7 @@ class DataSchemaGenerator(
             codeGenerator.createNewFile(Dependencies(true, importStatement.origin), packageName, "$name.Generated")
 
         val formats = listOf(
+            // TODO new Csv() and Tsv()
             CSV(delimiter = importStatement.csvOptions.delimiter),
             JSON(
                 typeClashTactic = importStatement.jsonOptions.typeClashTactic,