From 228418581aefc3342e5023f8c5151768b59b1fc1 Mon Sep 17 00:00:00 2001
From: "andrei.kislitsyn" <kisandy@yandex.ru>
Date: Mon, 14 Jul 2025 17:05:04 +0400
Subject: [PATCH 1/5] data schemas topics fix

---
 docs/StardustDocs/d.tree                      |  22 ++--
 docs/StardustDocs/topics/concepts/schemas.md  |  46 --------
 .../DataSchemaGenerationGradle.md             |   0
 .../DataSchemaGenerationMethods.md            |   0
 docs/StardustDocs/topics/schemas/schemas.md   | 110 ++++++++++++++++++
 .../{concepts => schemas}/schemasCustom.md    |   0
 .../schemasExternalJupyter.md                 |   0
 .../{concepts => schemas}/schemasGradle.md    |   0
 .../schemasImportOpenApiGradle.md             |   0
 .../schemasImportOpenApiJupyter.md            |   0
 .../schemasImportSqlGradle.md                 |   0
 .../schemasInheritance.md                     |   0
 .../{concepts => schemas}/schemasJupyter.md   |   0
 13 files changed, 121 insertions(+), 57 deletions(-)
 delete mode 100644 docs/StardustDocs/topics/concepts/schemas.md
 rename docs/StardustDocs/topics/{concepts => schemas}/DataSchemaGenerationGradle.md (100%)
 rename docs/StardustDocs/topics/{concepts => schemas}/DataSchemaGenerationMethods.md (100%)
 create mode 100644 docs/StardustDocs/topics/schemas/schemas.md
 rename docs/StardustDocs/topics/{concepts => schemas}/schemasCustom.md (100%)
 rename docs/StardustDocs/topics/{concepts => schemas}/schemasExternalJupyter.md (100%)
 rename docs/StardustDocs/topics/{concepts => schemas}/schemasGradle.md (100%)
 rename docs/StardustDocs/topics/{concepts => schemas}/schemasImportOpenApiGradle.md (100%)
 rename docs/StardustDocs/topics/{concepts => schemas}/schemasImportOpenApiJupyter.md (100%)
 rename docs/StardustDocs/topics/{concepts => schemas}/schemasImportSqlGradle.md (100%)
 rename docs/StardustDocs/topics/{concepts => schemas}/schemasInheritance.md (100%)
 rename docs/StardustDocs/topics/{concepts => schemas}/schemasJupyter.md (100%)

diff --git a/docs/StardustDocs/d.tree b/docs/StardustDocs/d.tree
index 42a51a1b76..a859fa33d3 100644
--- a/docs/StardustDocs/d.tree
+++ b/docs/StardustDocs/d.tree
@@ -32,19 +32,19 @@
         <toc-element topic="hierarchical.md"/>
         <toc-element topic="nanAndNa.md"/>
         <toc-element topic="numberUnification.md"/>
-        <toc-element topic="schemas.md">
-            <toc-element topic="schemasGradle.md"/>
-            <toc-element topic="schemasJupyter.md"/>
-            <toc-element topic="schemasInheritance.md"/>
-            <toc-element topic="schemasCustom.md"/>
-            <toc-element topic="schemasExternalJupyter.md"/>
-            <toc-element topic="schemasImportSqlGradle.md"/>
-            <toc-element topic="schemasImportOpenApiGradle.md"/>
-            <toc-element topic="schemasImportOpenApiJupyter.md"/>
-            <toc-element topic="DataSchemaGenerationGradle.md"/>
-        </toc-element>
     </toc-element>
     <toc-element topic="extensionPropertiesApi.md"/>
+    <toc-element topic="schemas.md">
+        <toc-element topic="schemasGradle.md"/>
+        <toc-element topic="schemasJupyter.md"/>
+        <toc-element topic="schemasInheritance.md"/>
+        <toc-element topic="schemasCustom.md"/>
+        <toc-element topic="schemasExternalJupyter.md"/>
+        <toc-element topic="schemasImportSqlGradle.md"/>
+        <toc-element topic="schemasImportOpenApiGradle.md"/>
+        <toc-element topic="schemasImportOpenApiJupyter.md"/>
+        <toc-element topic="DataSchemaGenerationGradle.md"/>
+    </toc-element>
     <toc-element topic="DataSchemaGenerationMethods.md"/>
     <toc-element topic="Compiler-Plugin.md">
         <toc-element topic="staticInterpretation.md"/>
diff --git a/docs/StardustDocs/topics/concepts/schemas.md b/docs/StardustDocs/topics/concepts/schemas.md
deleted file mode 100644
index 7a921bd08f..0000000000
--- a/docs/StardustDocs/topics/concepts/schemas.md
+++ /dev/null
@@ -1,46 +0,0 @@
-[//]: # (title: Working with Data Schemas)
-
-<!---IMPORT org.jetbrains.kotlinx.dataframe.samples.api.Schemas-->
-
-The Kotlin DataFrame library provides typed data access via [generation of extension properties](extensionPropertiesApi.md) for
-type `DataFrame<T>`, where
-`T` is a marker class that represents `DataSchema` of [`DataFrame`](DataFrame.md).
-
-Schema of [`DataFrame`](DataFrame.md) is a mapping from column names to column types of [`DataFrame`](DataFrame.md).
-It ignores order of columns in [`DataFrame`](DataFrame.md), but tracks column hierarchy.
-
-In Jupyter environment compile-time [`DataFrame`](DataFrame.md) schema is synchronized with real-time data after every cell execution.
-
-In IDEA projects, you can use the [Gradle plugin](schemasGradle.md#configuration) to extract schema from the dataset
-and generate extension properties.
-
-
-## Popular use cases with Data Schemas
-
-Here's a list of the most popular use cases with Data Schemas.
-
-* [**Data Schemas in Gradle projects**](schemasGradle.md) <br/>
-  If you are developing a server application and building it with Gradle.
-
-* [**DataSchema workflow in Jupyter**](schemasJupyter.md) <br/>
-  If you prefer Notebooks.
-
-* [**Schema inheritance**](schemasInheritance.md) <br/>
-  It's worth knowing how to reuse Data Schemas generated earlier.
-
-* [**Custom Data Schemas**](schemasCustom.md) <br/> 
-  Sometimes it is necessary to create your own scheme.
-
-* [**Use external Data Schemas in Jupyter**](schemasExternalJupyter.md) <br/>
-  Sometimes it is convenient to extract reusable code from Jupyter Notebook into the Kotlin JVM library.
-  Schema interfaces should also be extracted if this code uses Custom Data Schemas.
-
-* [**Schema Definitions from SQL Databases in Gradle Project**](schemasImportSqlGradle.md) <br/>
-  When you need to take data from the SQL database.
-
-* [**Import OpenAPI 3.0.0 Schemas (Experimental) in Gradle Project**](schemasImportOpenApiGradle.md) <br/>
-  When you need to take data from the endpoint with OpenAPI Schema.
-
-* [**Import Data Schemas, e.g. from OpenAPI 3.0.0 (Experimental), in Jupyter**](schemasImportOpenApiJupyter.md) <br/>
-  Similar to [importing OpenAPI Data Schemas in Gradle projects](schemasImportOpenApiGradle.md), 
-  you can also do this in Jupyter Notebooks.
diff --git a/docs/StardustDocs/topics/concepts/DataSchemaGenerationGradle.md b/docs/StardustDocs/topics/schemas/DataSchemaGenerationGradle.md
similarity index 100%
rename from docs/StardustDocs/topics/concepts/DataSchemaGenerationGradle.md
rename to docs/StardustDocs/topics/schemas/DataSchemaGenerationGradle.md
diff --git a/docs/StardustDocs/topics/concepts/DataSchemaGenerationMethods.md b/docs/StardustDocs/topics/schemas/DataSchemaGenerationMethods.md
similarity index 100%
rename from docs/StardustDocs/topics/concepts/DataSchemaGenerationMethods.md
rename to docs/StardustDocs/topics/schemas/DataSchemaGenerationMethods.md
diff --git a/docs/StardustDocs/topics/schemas/schemas.md b/docs/StardustDocs/topics/schemas/schemas.md
new file mode 100644
index 0000000000..ae81ae4703
--- /dev/null
+++ b/docs/StardustDocs/topics/schemas/schemas.md
@@ -0,0 +1,110 @@
+[//]: # (title: Data Schemas)
+
+The Kotlin DataFrame library provides typed data access via 
+[generation of extension properties](extensionPropertiesApi.md) for type 
+[`DataFrame<T>`](DataFrame.md) (as well as [`DataRow<T>`](DataRow.md)), where
+`T` is a marker class that represents `DataSchema` of [`DataFrame`](DataFrame.md).
+
+Schema of [`DataFrame`](DataFrame.md) is a mapping from column names to column types of [`DataFrame`](DataFrame.md).
+Data schema can be interpreted as a Kotlin interface or class. If the dataframe is hierarchical -  contains 
+[column group](DataColumn.md#columngroup) or [column of dataframes](DataColumn.md#framecolumn), data schema
+takes it into account and there is a separate class for each column group or inner `DataFrame`.
+
+For example, consider a simple hierarchical dataframe from
+<resource src="example.csv"></resource>.
+
+This dataframe consists of two columns: `name`, which is a `String` column, and `info`,
+which is a [**column group**](DataColumn.md#columngroup) containing two nested
+[value columns](DataColumn.md#valuecolumn) —
+`age` of type `Int`, and `height` of type `Double`.
+
+<table>
+  <thead>
+    <tr>
+      <th>name</th>
+      <th colspan="2">info</th>
+    </tr>
+    <tr>
+      <th></th>
+      <th>age</th>
+      <th>height</th>
+    </tr>
+  </thead>
+  <tbody>
+    <tr>
+      <td>Alice</td>
+      <td>23</td>
+      <td>175.5</td>
+    </tr>
+    <tr>
+      <td>Bob</td>
+      <td>27</td>
+      <td>160.2</td>
+    </tr>
+  </tbody>
+</table>
+
+Data schema corresponding to this dataframe can be represented like this :
+
+```kotlin
+// Data schema of the "info" column group
+@DataSchema
+data class Info(
+    val age: Int,
+    val height: Float
+)
+
+// Data schema of the entire dataframe
+@DataSchema
+data class Person(
+    val info: Info,
+    val name: String
+)
+```
+
+[Extension properties](extensionPropertiesApi.md) for the `DataFrame<Person>`
+are generated according to this schema and can be used for accessing columns and usage in operations:
+
+```kotlin
+// Assuming `df` has type DataFrame<Person>
+
+// Get "age" column from "info" group
+df.info.age
+
+// Select "name" and "height" columns
+df.select { name and info.height }
+
+// Filter rows by age value
+df.filter { age >= 18}
+```
+
+
+## Popular use cases with Data Schemas
+
+Here's a list of the most popular use cases with Data Schemas.
+
+* [**Data Schemas in Gradle projects**](schemasGradle.md) <br/>
+  If you are developing a server application and building it with Gradle.
+
+* [**DataSchema workflow in Jupyter**](schemasJupyter.md) <br/>
+  If you prefer Notebooks.
+
+* [**Schema inheritance**](schemasInheritance.md) <br/>
+  It's worth knowing how to reuse Data Schemas generated earlier.
+
+* [**Custom Data Schemas**](schemasCustom.md) <br/> 
+  Sometimes it is necessary to create your own scheme.
+
+* [**Use external Data Schemas in Jupyter**](schemasExternalJupyter.md) <br/>
+  Sometimes it is convenient to extract reusable code from Jupyter Notebook into the Kotlin JVM library.
+  Schema interfaces should also be extracted if this code uses Custom Data Schemas.
+
+* [**Schema Definitions from SQL Databases in Gradle Project**](schemasImportSqlGradle.md) <br/>
+  When you need to take data from the SQL database.
+
+* [**Import OpenAPI 3.0.0 Schemas (Experimental) in Gradle Project**](schemasImportOpenApiGradle.md) <br/>
+  When you need to take data from the endpoint with OpenAPI Schema.
+
+* [**Import Data Schemas, e.g. from OpenAPI 3.0.0 (Experimental), in Jupyter**](schemasImportOpenApiJupyter.md) <br/>
+  Similar to [importing OpenAPI Data Schemas in Gradle projects](schemasImportOpenApiGradle.md), 
+  you can also do this in Jupyter Notebooks.
diff --git a/docs/StardustDocs/topics/concepts/schemasCustom.md b/docs/StardustDocs/topics/schemas/schemasCustom.md
similarity index 100%
rename from docs/StardustDocs/topics/concepts/schemasCustom.md
rename to docs/StardustDocs/topics/schemas/schemasCustom.md
diff --git a/docs/StardustDocs/topics/concepts/schemasExternalJupyter.md b/docs/StardustDocs/topics/schemas/schemasExternalJupyter.md
similarity index 100%
rename from docs/StardustDocs/topics/concepts/schemasExternalJupyter.md
rename to docs/StardustDocs/topics/schemas/schemasExternalJupyter.md
diff --git a/docs/StardustDocs/topics/concepts/schemasGradle.md b/docs/StardustDocs/topics/schemas/schemasGradle.md
similarity index 100%
rename from docs/StardustDocs/topics/concepts/schemasGradle.md
rename to docs/StardustDocs/topics/schemas/schemasGradle.md
diff --git a/docs/StardustDocs/topics/concepts/schemasImportOpenApiGradle.md b/docs/StardustDocs/topics/schemas/schemasImportOpenApiGradle.md
similarity index 100%
rename from docs/StardustDocs/topics/concepts/schemasImportOpenApiGradle.md
rename to docs/StardustDocs/topics/schemas/schemasImportOpenApiGradle.md
diff --git a/docs/StardustDocs/topics/concepts/schemasImportOpenApiJupyter.md b/docs/StardustDocs/topics/schemas/schemasImportOpenApiJupyter.md
similarity index 100%
rename from docs/StardustDocs/topics/concepts/schemasImportOpenApiJupyter.md
rename to docs/StardustDocs/topics/schemas/schemasImportOpenApiJupyter.md
diff --git a/docs/StardustDocs/topics/concepts/schemasImportSqlGradle.md b/docs/StardustDocs/topics/schemas/schemasImportSqlGradle.md
similarity index 100%
rename from docs/StardustDocs/topics/concepts/schemasImportSqlGradle.md
rename to docs/StardustDocs/topics/schemas/schemasImportSqlGradle.md
diff --git a/docs/StardustDocs/topics/concepts/schemasInheritance.md b/docs/StardustDocs/topics/schemas/schemasInheritance.md
similarity index 100%
rename from docs/StardustDocs/topics/concepts/schemasInheritance.md
rename to docs/StardustDocs/topics/schemas/schemasInheritance.md
diff --git a/docs/StardustDocs/topics/concepts/schemasJupyter.md b/docs/StardustDocs/topics/schemas/schemasJupyter.md
similarity index 100%
rename from docs/StardustDocs/topics/concepts/schemasJupyter.md
rename to docs/StardustDocs/topics/schemas/schemasJupyter.md

From 9a7fb0fb4427c3b531db2aec139855e06737a208 Mon Sep 17 00:00:00 2001
From: "andrei.kislitsyn" <kisandy@yandex.ru>
Date: Tue, 22 Jul 2025 18:18:02 +0400
Subject: [PATCH 2/5] data schemas docs restructure

---
 docs/StardustDocs/d.tree                      |  16 +-
 docs/StardustDocs/topics/FAQ.md               |  21 +-
 .../topics/gettingStarted/Modules.md          |   2 +-
 .../topics/readSqlFromCustomDatabase.md       |   2 +-
 .../Data-Schemas-In-Kotlin-Notebook.md        | 180 ++++++++++++++++++
 .../schemas/DataSchemaGenerationMethods.md    |   4 +-
 .../topics/schemas/Migration-From-Plugins.md  |  44 +++++
 .../Gradle-Plugin.md}                         |   2 +-
 .../schemas/{ => gradle}/schemasGradle.md     |   2 +-
 .../schemasImportOpenApiGradle.md             |   0
 .../{ => gradle}/schemasImportSqlGradle.md    |   0
 docs/StardustDocs/topics/schemas/schemas.md   | 114 +++++++----
 .../topics/schemas/schemasCustom.md           |  80 --------
 .../topics/schemas/schemasExternalJupyter.md  |  50 -----
 .../schemas/schemasImportOpenApiJupyter.md    |   4 +-
 .../topics/schemas/schemasJupyter.md          |  58 ------
 16 files changed, 324 insertions(+), 255 deletions(-)
 create mode 100644 docs/StardustDocs/topics/schemas/Data-Schemas-In-Kotlin-Notebook.md
 create mode 100644 docs/StardustDocs/topics/schemas/Migration-From-Plugins.md
 rename docs/StardustDocs/topics/schemas/{DataSchemaGenerationGradle.md => gradle/Gradle-Plugin.md} (99%)
 rename docs/StardustDocs/topics/schemas/{ => gradle}/schemasGradle.md (97%)
 rename docs/StardustDocs/topics/schemas/{ => gradle}/schemasImportOpenApiGradle.md (100%)
 rename docs/StardustDocs/topics/schemas/{ => gradle}/schemasImportSqlGradle.md (100%)
 delete mode 100644 docs/StardustDocs/topics/schemas/schemasCustom.md
 delete mode 100644 docs/StardustDocs/topics/schemas/schemasExternalJupyter.md
 delete mode 100644 docs/StardustDocs/topics/schemas/schemasJupyter.md

diff --git a/docs/StardustDocs/d.tree b/docs/StardustDocs/d.tree
index 54225b918a..f2ef4fd112 100644
--- a/docs/StardustDocs/d.tree
+++ b/docs/StardustDocs/d.tree
@@ -35,17 +35,16 @@
     </toc-element>
     <toc-element topic="extensionPropertiesApi.md"/>
     <toc-element topic="schemas.md">
-        <toc-element topic="schemasGradle.md"/>
-        <toc-element topic="schemasJupyter.md"/>
+        <toc-element topic="DataSchemaGenerationMethods.md"/>
         <toc-element topic="schemasInheritance.md"/>
-        <toc-element topic="schemasCustom.md"/>
-        <toc-element topic="schemasExternalJupyter.md"/>
-        <toc-element topic="schemasImportSqlGradle.md"/>
-        <toc-element topic="schemasImportOpenApiGradle.md"/>
+        <toc-element topic="Data-Schemas-In-Kotlin-Notebook.md"/>
         <toc-element topic="schemasImportOpenApiJupyter.md"/>
-        <toc-element topic="DataSchemaGenerationGradle.md"/>
+        <toc-element topic="Gradle-Plugin.md">
+            <toc-element topic="schemasGradle.md"/>
+            <toc-element topic="schemasImportSqlGradle.md"/>
+            <toc-element topic="schemasImportOpenApiGradle.md"/>
+        </toc-element>
     </toc-element>
-    <toc-element topic="DataSchemaGenerationMethods.md"/>
     <toc-element topic="Compiler-Plugin.md">
         <toc-element topic="staticInterpretation.md"/>
         <toc-element topic="dataSchema.md"/>
@@ -194,4 +193,5 @@
     <toc-element topic="_shadow_resources.md" hidden="true"/>
     <toc-element topic="Support.md"/>
     <toc-element topic="FAQ.md"/>
+    <toc-element topic="Migration-From-Plugins.md"/>
 </instance-profile>
diff --git a/docs/StardustDocs/topics/FAQ.md b/docs/StardustDocs/topics/FAQ.md
index e805f7813a..852232c35f 100644
--- a/docs/StardustDocs/topics/FAQ.md
+++ b/docs/StardustDocs/topics/FAQ.md
@@ -174,15 +174,17 @@ and examples with beautiful [Kandy](https://kotlin.github.io/kandy) geo visualiz
 
 > The current Gradle plugin is **under consideration for deprecation** and may be officially marked as deprecated 
 > in future releases.
-> The KSP plugin doesn't work for now.
+> 
+> The KSP plugin is **not compatible with Kotlin 2.1 or newer**.
 >
 > At the moment, **[data schema generation is handled via dedicated methods](DataSchemaGenerationMethods.md)** instead 
-> of relying on the plugins.
+> of relying on the plugins. 
+> See [](Migration-From-Plugins.md).
 {style="warning"}
 
 All these plugins relate to working with [dataframe schemas](schemas.md), but they serve different purposes:
 
-- **[Gradle Plugin](DataSchemaGenerationGradle.md)** and **[KSP Plugin](https://github.com/Kotlin/dataframe/tree/master/plugins/symbol-processor)** 
+- **[Gradle Plugin](Gradle-Plugin.md)** and **[KSP Plugin](https://github.com/Kotlin/dataframe/tree/master/plugins/symbol-processor)** 
  are used to **generate data schemas** from external sources as part of the Gradle build process.
 
     - **Gradle Plugin**: You declare the data source in your `build.gradle.kts` file  
@@ -193,12 +195,13 @@ All these plugins relate to working with [dataframe schemas](schemas.md), but th
 
   See [Data Schemas in Gradle Projects](https://kotlin.github.io/dataframe/schemasgradle.html) for more.
 
-- **[Compiler Plugin](Compiler-Plugin.md)**
- provides **on-the-fly generation** of [extension properties](extensionPropertiesApi.md)  
- based on an existing schema **during compilation**.
- However, when reading data from files or external sources (like SQL),
- the schema cannot be inferred automatically — you need to 
- specify it manually or use the Gradle or KSP plugin to generate it.
+- **[Compiler Plugin](Compiler-Plugin.md)** provides **on-the-fly generation** of 
+[extension properties](extensionPropertiesApi.md)
+based on an existing schema **during compilation**, and updates the [`DataFrame`](DataFrame.md)
+schema seamlessly after operations.
+However, when reading data from files or external sources (like SQL),
+the initial `DataFrame` schema cannot be inferred automatically —
+you need to specify it manually or generate it using the [`generate..()` methods](DataSchemaGenerationMethods.md).
 
 ## How do I contribute or report an issue?
 
diff --git a/docs/StardustDocs/topics/gettingStarted/Modules.md b/docs/StardustDocs/topics/gettingStarted/Modules.md
index 257f2dbc37..be8a087ea7 100644
--- a/docs/StardustDocs/topics/gettingStarted/Modules.md
+++ b/docs/StardustDocs/topics/gettingStarted/Modules.md
@@ -517,7 +517,7 @@ The Gradle plugin allows generating [data schemas](schemas.md) from samples of d
 (of supported formats) like JSON, CSV, Excel files, or URLs, as well as from data fetched from SQL databases  
 using Gradle.
 
-See the [Gradle Plugin Reference](DataSchemaGenerationGradle.md) for installation  
+See the [Gradle Plugin Reference](Gradle-Plugin.md) for installation  
 and usage instructions in Gradle projects.
 
 > By default, the Gradle plugin also applies the [KSP plugin](#ksp-plugin).
diff --git a/docs/StardustDocs/topics/readSqlFromCustomDatabase.md b/docs/StardustDocs/topics/readSqlFromCustomDatabase.md
index 57e1931630..f3e2660493 100644
--- a/docs/StardustDocs/topics/readSqlFromCustomDatabase.md
+++ b/docs/StardustDocs/topics/readSqlFromCustomDatabase.md
@@ -129,7 +129,7 @@ fun createAndPopulateTable(con: Connection) {
 
 **Define the Table Schema**
 
-Use the `@DataSchema` annotation to define a [**custom data schema**](schemasCustom.md) for the `orders` table.
+Use the `@DataSchema` annotation to define a [**custom data schema**](schemas.md) for the `orders` table.
 
 ```kotlin
 @DataSchema
diff --git a/docs/StardustDocs/topics/schemas/Data-Schemas-In-Kotlin-Notebook.md b/docs/StardustDocs/topics/schemas/Data-Schemas-In-Kotlin-Notebook.md
new file mode 100644
index 0000000000..873480cc40
--- /dev/null
+++ b/docs/StardustDocs/topics/schemas/Data-Schemas-In-Kotlin-Notebook.md
@@ -0,0 +1,180 @@
+[//]: # (title: Data Schemas in Kotlin Notebook)
+
+<!---IMPORT org.jetbrains.kotlinx.dataframe.samples.api.Schemas-->
+
+After execution of a cell
+
+<!---FUN createDfNullable-->
+
+```kotlin
+val df = dataFrameOf("name", "age")(
+    "Alice", 15,
+    "Bob", null,
+)
+```
+
+<!---END-->
+
+the following actions take place:
+
+1. Columns in `df` are analyzed to extract data schema
+2. Empty interface with [`DataSchema`](schema.md) annotation is generated:
+
+```kotlin
+@DataSchema
+interface DataFrameType
+```
+
+3. Extension properties for this [`DataSchema`](schema.md) are generated:
+
+```kotlin
+val ColumnsContainer<DataFrameType>.age: DataColumn<Int?> @JvmName("DataFrameType_age") get() = this["age"] as DataColumn<Int?>
+val DataRow<DataFrameType>.age: Int? @JvmName("DataFrameType_age") get() = this["age"] as Int?
+val ColumnsContainer<DataFrameType>.name: DataColumn<String> @JvmName("DataFrameType_name") get() = this["name"] as DataColumn<String>
+val DataRow<DataFrameType>.name: String @JvmName("DataFrameType_name") get() = this["name"] as String
+```
+
+Every column produces two extension properties:
+
+* Property for `ColumnsContainer<DataFrameType>` returns column
+* Property for `DataRow<DataFrameType>` returns cell value
+
+4. `df` variable is typed by schema interface:
+
+```kotlin
+val temp = df
+```
+
+```kotlin
+val df = temp.cast<DataFrameType>()
+```
+
+> _Note, that object instance after casting remains the same. See [cast](cast.md).
+
+To log all these additional code executions, use cell magic
+
+```
+%trackExecution -all
+```
+
+## Custom Data Schemas
+
+You can define your own [`DataSchema`](schema.md) interfaces and use them in functions and classes to represent [`DataFrame`](DataFrame.md) with
+a specific set of columns:
+
+```kotlin
+@DataSchema
+interface Person {
+    val name: String
+    val age: Int
+}
+```
+
+After execution of this cell in notebook or annotation processing in IDEA, extension properties for data access will be
+generated. Now we can use these properties to create functions for typed [`DataFrame`](DataFrame.md):
+
+```kotlin
+fun DataFrame<Person>.splitName() = split { name }.by(",").into("firstName", "lastName")
+fun DataFrame<Person>.adults() = filter { age > 18 }
+```
+
+In Kotlin Notebook these functions will work automatically for any [`DataFrame`](DataFrame.md) that matches `Person` schema:
+
+<!---FUN extendedDf-->
+
+```kotlin
+val df = dataFrameOf("name", "age", "weight")(
+    "Merton, Alice", 15, 60.0,
+    "Marley, Bob", 20, 73.5,
+)
+```
+
+<!---END-->
+
+Schema of `df` is compatible with `Person`, so auto-generated schema interface will inherit from it:
+
+```kotlin
+@DataSchema(isOpen = false)
+interface DataFrameType : Person
+
+val ColumnsContainer<DataFrameType>.weight: DataColumn<Double> get() = this["weight"] as DataColumn<Double>
+val DataRow<DataFrameType>.weight: Double get() = this["weight"] as Double
+```
+
+Despite `df` has additional column `weight`, previously defined functions for `DataFrame<Person>` will work for it:
+
+<!---FUN splitNameWorks-->
+
+```kotlin
+df.splitName()
+```
+
+<!---END-->
+
+```text
+firstName lastName age weight
+   Merton    Alice  15 60.000
+   Marley      Bob  20 73.125
+```
+
+<!---FUN adultsWorks-->
+
+```kotlin
+df.adults()
+```
+
+<!---END-->
+
+```text
+name        age weight
+Marley, Bob  20   73.5
+```
+
+## Use external Data Schemas
+
+Sometimes it is convenient to extract reusable code from Kotlin Notebook into the Kotlin JVM library.
+Schema interfaces should also be extracted if this code uses [Custom Data Schemas](#custom-data-schemas).
+
+In order to enable support them in Kotlin, you should register them in
+library [integration class](https://github.com/Kotlin/kotlin-jupyter/blob/master/docs/libraries.md) with `useSchema`
+function:
+
+```kotlin
+@DataSchema
+interface Person {
+    val name: String
+    val age: Int
+}
+
+fun DataFrame<Person>.countAdults() = count { it[Person::age] > 18 }
+
+@JupyterLibrary
+internal class Integration : JupyterIntegration() {
+
+    override fun Builder.onLoaded() {
+        onLoaded {
+            useSchema<Person>()
+        }
+    }
+}
+```
+
+After loading this library into the notebook, schema interfaces for all [`DataFrame`](DataFrame.md) variables that match `Person`
+schema will derive from `Person`
+
+<!---FUN createDf-->
+
+```kotlin
+val df = dataFrameOf("name", "age")(
+    "Alice", 15,
+    "Bob", 20,
+)
+```
+
+<!---END-->
+
+Now `df` is assignable to `DataFrame<Person>` and `countAdults` is available:
+
+```kotlin
+df.countAdults()
+```
diff --git a/docs/StardustDocs/topics/schemas/DataSchemaGenerationMethods.md b/docs/StardustDocs/topics/schemas/DataSchemaGenerationMethods.md
index 602c66db6e..2883a8be5b 100644
--- a/docs/StardustDocs/topics/schemas/DataSchemaGenerationMethods.md
+++ b/docs/StardustDocs/topics/schemas/DataSchemaGenerationMethods.md
@@ -1,4 +1,4 @@
-# Data Schemas Generation From Existing DataFrame
+# Data Schemas Generation Methods
 
 <web-summary>
 Generate useful Kotlin definitions based on your DataFrame structure.
@@ -164,7 +164,7 @@ val customers: List<Customer> = df.cast<Customer>().toList()
 
 <!---END-->
 
-## generateCode
+## generateCode {id="generate-code"}
 
 ```kotlin
 inline fun <reified T> DataFrame<T>.generateCode(
diff --git a/docs/StardustDocs/topics/schemas/Migration-From-Plugins.md b/docs/StardustDocs/topics/schemas/Migration-From-Plugins.md
new file mode 100644
index 0000000000..fbc977a706
--- /dev/null
+++ b/docs/StardustDocs/topics/schemas/Migration-From-Plugins.md
@@ -0,0 +1,44 @@
+# Migration from Gradle/KSP Plugin
+
+Gradle and KSP plugins were useful tools in earlier versions of Kotlin DataFrame.  
+However, they are now being phased out. This section provides an overview of their current state and migration guidance.
+
+## Gradle Plugin
+
+> Do not confuse this with the [](Compiler-Plugin.md), which is a Kotlin compiler plugin
+> and has a different plugin ID.  
+> {style="note"}
+
+1. **Generation of [data schemas](schemas.md)** from data sources  
+   (files, databases, or external URLs).
+    - You could copy already generated schemas from `build/generate` into your project sources.
+    - To generate a `DataSchema` for a [`DataFrame`](DataFrame.md) now, use
+      the [`generate..()` methods](DataSchemaGenerationMethods.md).
+
+2. **Generation of [extension properties](extensionPropertiesApi.md)** from data schemas  
+   This is now handled by the [](Compiler-Plugin.md), which:
+    - Generates extension properties for declared data schemas.
+    - Automatically updates the schema and regenerates properties after structural DataFrame operations.
+
+> The Gradle plugin still works and may be helpful for generating schemas from data sources.  
+> However, it is planned for deprecation, and **we do not recommend using it going forward**.  
+> {style="warning"}
+
+If you still choose to use it, make sure to disable the automatic KSP dependency 
+to avoid compatibility issues with Kotlin 2.1+ by adding this line to `gradle.properties`:
+
+```properties
+kotlin.dataframe.add.ksp=false
+```
+
+## KSP Plugin
+
+> The KSP plugin is **not compatible with Kotlin 2.1 or newer**.  
+> It is planned for deprecation or major changes, and **we do not recommend using it at this time**.  
+> {style="warning"}
+
+- **Generation of [data schemas](schemas.md)** from data sources  
+  (files, databases, or external URLs).
+    - You could copy already generated schemas from `build/generate/ksp` into your project sources.
+    - To generate a `DataSchema` for a [`DataFrame`](DataFrame.md) now, use the  
+      [`generate..()` methods](DataSchemaGenerationMethods.md) instead.
diff --git a/docs/StardustDocs/topics/schemas/DataSchemaGenerationGradle.md b/docs/StardustDocs/topics/schemas/gradle/Gradle-Plugin.md
similarity index 99%
rename from docs/StardustDocs/topics/schemas/DataSchemaGenerationGradle.md
rename to docs/StardustDocs/topics/schemas/gradle/Gradle-Plugin.md
index 1ff1a81c53..e3e9b25651 100644
--- a/docs/StardustDocs/topics/schemas/DataSchemaGenerationGradle.md
+++ b/docs/StardustDocs/topics/schemas/gradle/Gradle-Plugin.md
@@ -1,4 +1,4 @@
-[//]: # (title: Data Shemas Generation in Gradle)
+[//]: # (title: Gradle Plugin (deprecated))
 
 > The current Gradle plugin is **under consideration for deprecation** and may be officially marked as deprecated in future releases.
 >
diff --git a/docs/StardustDocs/topics/schemas/schemasGradle.md b/docs/StardustDocs/topics/schemas/gradle/schemasGradle.md
similarity index 97%
rename from docs/StardustDocs/topics/schemas/schemasGradle.md
rename to docs/StardustDocs/topics/schemas/gradle/schemasGradle.md
index ead7311457..44e75cf569 100644
--- a/docs/StardustDocs/topics/schemas/schemasGradle.md
+++ b/docs/StardustDocs/topics/schemas/gradle/schemasGradle.md
@@ -136,7 +136,7 @@ dataframes {
 }
 ```
 
-See [reference](DataSchemaGenerationGradle.md) and [examples](DataSchemaGenerationGradle.md#examples) for more details.
+See [reference](Gradle-Plugin.md) and [examples](Gradle-Plugin.md#examples) for more details.
 
 </tab>
 </tabs>
diff --git a/docs/StardustDocs/topics/schemas/schemasImportOpenApiGradle.md b/docs/StardustDocs/topics/schemas/gradle/schemasImportOpenApiGradle.md
similarity index 100%
rename from docs/StardustDocs/topics/schemas/schemasImportOpenApiGradle.md
rename to docs/StardustDocs/topics/schemas/gradle/schemasImportOpenApiGradle.md
diff --git a/docs/StardustDocs/topics/schemas/schemasImportSqlGradle.md b/docs/StardustDocs/topics/schemas/gradle/schemasImportSqlGradle.md
similarity index 100%
rename from docs/StardustDocs/topics/schemas/schemasImportSqlGradle.md
rename to docs/StardustDocs/topics/schemas/gradle/schemasImportSqlGradle.md
diff --git a/docs/StardustDocs/topics/schemas/schemas.md b/docs/StardustDocs/topics/schemas/schemas.md
index ae81ae4703..0bed1977b0 100644
--- a/docs/StardustDocs/topics/schemas/schemas.md
+++ b/docs/StardustDocs/topics/schemas/schemas.md
@@ -1,22 +1,24 @@
 [//]: # (title: Data Schemas)
 
-The Kotlin DataFrame library provides typed data access via 
-[generation of extension properties](extensionPropertiesApi.md) for type 
-[`DataFrame<T>`](DataFrame.md) (as well as [`DataRow<T>`](DataRow.md)), where
-`T` is a marker class that represents `DataSchema` of [`DataFrame`](DataFrame.md).
-
-Schema of [`DataFrame`](DataFrame.md) is a mapping from column names to column types of [`DataFrame`](DataFrame.md).
-Data schema can be interpreted as a Kotlin interface or class. If the dataframe is hierarchical -  contains 
-[column group](DataColumn.md#columngroup) or [column of dataframes](DataColumn.md#framecolumn), data schema
-takes it into account and there is a separate class for each column group or inner `DataFrame`.
-
-For example, consider a simple hierarchical dataframe from
+The Kotlin DataFrame library provides typed data access via
+[generation of extension properties](extensionPropertiesApi.md) for the type
+[`DataFrame<T>`](DataFrame.md) (as well as for [`DataRow<T>`](DataRow.md)), where
+`T` is a marker class representing the `DataSchema` of the [`DataFrame`](DataFrame.md).
+
+A *schema* of a [`DataFrame`](DataFrame.md) is a mapping from column names to column types.  
+This data schema can be expressed as a Kotlin class or interface.  
+If the DataFrame is hierarchical — contains a [column group](DataColumn.md#columngroup) or a
+[column of dataframes](DataColumn.md#framecolumn) — the data schema reflects this structure,
+with a separate class representing the schema of each column group or nested `DataFrame`.
+
+For example, consider a simple hierarchical DataFrame from
 <resource src="example.csv"></resource>.
 
-This dataframe consists of two columns: `name`, which is a `String` column, and `info`,
-which is a [**column group**](DataColumn.md#columngroup) containing two nested
-[value columns](DataColumn.md#valuecolumn) —
-`age` of type `Int`, and `height` of type `Double`.
+This DataFrame consists of two columns:
+- `name`, which is a `String` column
+- `info`, which is a [column group](DataColumn.md#columngroup) containing two nested [value columns](DataColumn.md#valuecolumn):
+    - `age` of type `Int`
+    - `height` of type `Double`
 
 <table>
   <thead>
@@ -44,7 +46,7 @@ which is a [**column group**](DataColumn.md#columngroup) containing two nested
   </tbody>
 </table>
 
-Data schema corresponding to this dataframe can be represented like this :
+The data schema corresponding to this DataFrame can be represented as:
 
 ```kotlin
 // Data schema of the "info" column group
@@ -54,7 +56,7 @@ data class Info(
     val height: Float
 )
 
-// Data schema of the entire dataframe
+// Data schema of the entire DataFrame
 @DataSchema
 data class Person(
     val info: Info,
@@ -62,11 +64,12 @@ data class Person(
 )
 ```
 
-[Extension properties](extensionPropertiesApi.md) for the `DataFrame<Person>`
-are generated according to this schema and can be used for accessing columns and usage in operations:
+[Extension properties](extensionPropertiesApi.md) for `DataFrame<Person>`  
+are generated based on this schema and allow accessing columns
+or using them in operations:
 
 ```kotlin
-// Assuming `df` has type DataFrame<Person>
+// Assuming `df` has type `DataFrame<Person>`
 
 // Get "age" column from "info" group
 df.info.age
@@ -74,37 +77,64 @@ df.info.age
 // Select "name" and "height" columns
 df.select { name and info.height }
 
-// Filter rows by age value
-df.filter { age >= 18}
+// Filter rows by "age"
+df.filter { age >= 18 }
 ```
 
+See [](extensionPropertiesApi.md) for more information.
+
+
+## Schemas retrieving
+
+Defining a data schema manually can be difficult, especially for dataframes with many columns or deeply nested structures, and may lead to mistakes in column names or types. Kotlin DataFrame provides several methods for generating data schemas.
+
+* [**`generate..()` methods**](DataSchemaGenerationMethods.md) are extensions for [`DataFrame`](DataFrame.md) that generate a code string representing its `DataSchema`.
+
+* [**Kotlin DataFrame Compiler Plugin**](Compiler-Plugin.md) **cannot automatically infer** a 
+data schema from external sources such as files or URLs.
+However, it **can** infer the schema if you construct the [`DataFrame`](DataFrame.md) 
+manually — that is, by explicitly declaring the columns using the API.
+It will also **automatically update** the schema during operations that modify the structure of the DataFrame.
+
+> For best results when working with the Compiler Plugin, it's recommended to 
+> generate the initial schema using one of 
+> the [`generate..()` methods](DataSchemaGenerationMethods.md).
+> Once generated, the Compiler Plugin will automatically keep the schema up to date 
+> after any operations that change the structure of the DataFrame.
+
+### Plugins
+
+> The current Gradle plugin is **under consideration for deprecation** and may be officially marked as deprecated in future releases.  
+> The KSP plugin is currently non-functional.
+>
+> At the moment, **[data schema generation is handled via dedicated methods](DataSchemaGenerationMethods.md)** instead of relying on the plugins.  
+{style="warning"}
 
-## Popular use cases with Data Schemas
+* The [Gradle plugin](Gradle-Plugin.md) allows generating a data schema automatically by specifying a source file path in the Gradle build script.
 
-Here's a list of the most popular use cases with Data Schemas.
+* The KSP plugin allows generating a data schema automatically using 
+[Kotlin Symbol Processing](https://kotlinlang.org/docs/ksp-overview.html) by specifying 
+a source file path in your code file.
 
-* [**Data Schemas in Gradle projects**](schemasGradle.md) <br/>
-  If you are developing a server application and building it with Gradle.
+## Extension properties generation
 
-* [**DataSchema workflow in Jupyter**](schemasJupyter.md) <br/>
-  If you prefer Notebooks.
+Once you have a data schema, you can generate [extension properties](extensionPropertiesApi.md).
 
-* [**Schema inheritance**](schemasInheritance.md) <br/>
-  It's worth knowing how to reuse Data Schemas generated earlier.
+The easiest and most convenient way is to use the [**Kotlin DataFrame Compiler Plugin**](Compiler-Plugin.md), 
+which generates extension properties on the fly for declared data schemas 
+and automatically keeps them up to date after operations 
+that modify the structure of the [`DataFrame`](DataFrame.md).
 
-* [**Custom Data Schemas**](schemasCustom.md) <br/> 
-  Sometimes it is necessary to create your own scheme.
+> Extension properties generation was deprecated from the Gradle plugin in favor of the Compiler Plugin.  
+> {style="warning"}
 
-* [**Use external Data Schemas in Jupyter**](schemasExternalJupyter.md) <br/>
-  Sometimes it is convenient to extract reusable code from Jupyter Notebook into the Kotlin JVM library.
-  Schema interfaces should also be extracted if this code uses Custom Data Schemas.
+* When using Kotlin DataFrame inside [Kotlin Notebook](gettingStartedKotlinNotebook.md), 
+the schema and extension properties
+are generated automatically after each cell execution for all `DataFrame` variables declared in that cell.
+See [extension properties example in Kotlin Notebook](extensionPropertiesApi.md#example).
 
-* [**Schema Definitions from SQL Databases in Gradle Project**](schemasImportSqlGradle.md) <br/>
-  When you need to take data from the SQL database.
+> Compiler Plugin is coming to Kotlin Notebook soon.
 
-* [**Import OpenAPI 3.0.0 Schemas (Experimental) in Gradle Project**](schemasImportOpenApiGradle.md) <br/>
-  When you need to take data from the endpoint with OpenAPI Schema.
+* If you're not using the Compiler Plugin, you can still generate extension properties for a [`DataFrame`](DataFrame.md)
+  using the [`generateCode`](DataSchemaGenerationMethods.md#generate-code) method.
 
-* [**Import Data Schemas, e.g. from OpenAPI 3.0.0 (Experimental), in Jupyter**](schemasImportOpenApiJupyter.md) <br/>
-  Similar to [importing OpenAPI Data Schemas in Gradle projects](schemasImportOpenApiGradle.md), 
-  you can also do this in Jupyter Notebooks.
diff --git a/docs/StardustDocs/topics/schemas/schemasCustom.md b/docs/StardustDocs/topics/schemas/schemasCustom.md
deleted file mode 100644
index 0f7f876b4a..0000000000
--- a/docs/StardustDocs/topics/schemas/schemasCustom.md
+++ /dev/null
@@ -1,80 +0,0 @@
-[//]: # (title: Custom Data Schemas)
-
-<!---IMPORT org.jetbrains.kotlinx.dataframe.samples.api.Schemas-->
-
-You can define your own [`DataSchema`](schema.md) interfaces and use them in functions and classes to represent [`DataFrame`](DataFrame.md) with
-specific set of columns:
-
-```kotlin
-@DataSchema
-interface Person {
-    val name: String
-    val age: Int
-}
-```
-
-After execution of this cell in Jupyter or annotation processing in IDEA, extension properties for data access will be
-generated. Now we can use these properties to create functions for typed [`DataFrame`](DataFrame.md):
-
-```kotlin
-fun DataFrame<Person>.splitName() = split { name }.by(",").into("firstName", "lastName")
-fun DataFrame<Person>.adults() = filter { age > 18 }
-```
-
-In Jupyter these functions will work automatically for any [`DataFrame`](DataFrame.md) that matches `Person` schema:
-
-<!---FUN extendedDf-->
-
-```kotlin
-val df = dataFrameOf("name", "age", "weight")(
-    "Merton, Alice", 15, 60.0,
-    "Marley, Bob", 20, 73.5,
-)
-```
-
-<!---END-->
-
-Schema of `df` is compatible with `Person`, so auto-generated schema interface will inherit from it:
-
-```kotlin
-@DataSchema(isOpen = false)
-interface DataFrameType : Person
-
-val ColumnsContainer<DataFrameType>.weight: DataColumn<Double> get() = this["weight"] as DataColumn<Double>
-val DataRow<DataFrameType>.weight: Double get() = this["weight"] as Double
-```
-
-Despite `df` has additional column `weight`, previously defined functions for `DataFrame<Person>` will work for it:
-
-<!---FUN splitNameWorks-->
-
-```kotlin
-df.splitName()
-```
-
-<!---END-->
-
-```text
-firstName lastName age weight
-   Merton    Alice  15 60.000
-   Marley      Bob  20 73.125
-```
-
-<!---FUN adultsWorks-->
-
-```kotlin
-df.adults()
-```
-
-<!---END-->
-
-```text
-name        age weight
-Marley, Bob  20   73.5
-```
-
-In JVM project you will have to [cast](cast.md) [`DataFrame`](DataFrame.md) explicitly to the target interface:
-
-```kotlin
-df.cast<Person>().splitName()
-```
diff --git a/docs/StardustDocs/topics/schemas/schemasExternalJupyter.md b/docs/StardustDocs/topics/schemas/schemasExternalJupyter.md
deleted file mode 100644
index 2b587b640e..0000000000
--- a/docs/StardustDocs/topics/schemas/schemasExternalJupyter.md
+++ /dev/null
@@ -1,50 +0,0 @@
-[//]: # (title: Use external Data Schemas in Jupyter)
-
-<!---IMPORT org.jetbrains.kotlinx.dataframe.samples.api.Schemas-->
-
-Sometimes it is convenient to extract reusable code from Jupyter Notebook into the Kotlin JVM library.
-Schema interfaces should also be extracted if this code uses [Custom Data Schemas](schemasCustom.md). 
-
-In order to enable support them in Jupyter, you should register them in
-library [integration class](https://github.com/Kotlin/kotlin-jupyter/blob/master/docs/libraries.md) with `useSchema`
-function:
-
-```kotlin
-@DataSchema
-interface Person {
-    val name: String
-    val age: Int
-}
-
-fun DataFrame<Person>.countAdults() = count { it[Person::age] > 18 }
-
-@JupyterLibrary
-internal class Integration : JupyterIntegration() {
-
-    override fun Builder.onLoaded() {
-        onLoaded {
-            useSchema<Person>()
-        }
-    }
-}
-```
-
-After loading this library into Jupyter notebook, schema interfaces for all [`DataFrame`](DataFrame.md) variables that match `Person`
-schema will derive from `Person`
-
-<!---FUN createDf-->
-
-```kotlin
-val df = dataFrameOf("name", "age")(
-    "Alice", 15,
-    "Bob", 20,
-)
-```
-
-<!---END-->
-
-Now `df` is assignable to `DataFrame<Person>` and `countAdults` is available:
-
-```kotlin
-df.countAdults()
-```
diff --git a/docs/StardustDocs/topics/schemas/schemasImportOpenApiJupyter.md b/docs/StardustDocs/topics/schemas/schemasImportOpenApiJupyter.md
index 118106afd8..2e41208a61 100644
--- a/docs/StardustDocs/topics/schemas/schemasImportOpenApiJupyter.md
+++ b/docs/StardustDocs/topics/schemas/schemasImportOpenApiJupyter.md
@@ -1,4 +1,4 @@
-[//]: # (title: Import Data Schemas, e.g. from OpenAPI, in Jupyter)
+[//]: # (title: Import Data Schemas, e.g. from OpenAPI, in Kotlin Notebook)
 
 <!---IMPORT org.jetbrains.kotlinx.dataframe.samples.api.Schemas-->
 
@@ -7,7 +7,7 @@ OpenAPI 3.0.0 schema support is marked as experimental. It might change or be re
 </warning>
 
 Similar to [importing OpenAPI Data Schemas in Gradle projects](schemasImportOpenApiGradle.md),
-you can also do this in Jupyter Notebooks.
+you can also do this in Kotlin Notebook.
 This requires enabling the `enableExperimentalOpenApi` setting, like:
 ```
 %use dataframe(..., enableExperimentalOpenApi=true)
diff --git a/docs/StardustDocs/topics/schemas/schemasJupyter.md b/docs/StardustDocs/topics/schemas/schemasJupyter.md
deleted file mode 100644
index 4e4c817e80..0000000000
--- a/docs/StardustDocs/topics/schemas/schemasJupyter.md
+++ /dev/null
@@ -1,58 +0,0 @@
-[//]: # (title: DataSchema workflow in Jupyter)
-
-<!---IMPORT org.jetbrains.kotlinx.dataframe.samples.api.Schemas-->
-
-After execution of cell
-
-<!---FUN createDfNullable-->
-
-```kotlin
-val df = dataFrameOf("name", "age")(
-    "Alice", 15,
-    "Bob", null,
-)
-```
-
-<!---END-->
-
-the following actions take place:
-
-1. Columns in `df` are analyzed to extract data schema
-2. Empty interface with [`DataSchema`](schema.md) annotation is generated:
-
-```kotlin
-@DataSchema
-interface DataFrameType
-```
-
-3. Extension properties for this [`DataSchema`](schema.md) are generated:
-
-```kotlin
-val ColumnsContainer<DataFrameType>.age: DataColumn<Int?> @JvmName("DataFrameType_age") get() = this["age"] as DataColumn<Int?>
-val DataRow<DataFrameType>.age: Int? @JvmName("DataFrameType_age") get() = this["age"] as Int?
-val ColumnsContainer<DataFrameType>.name: DataColumn<String> @JvmName("DataFrameType_name") get() = this["name"] as DataColumn<String>
-val DataRow<DataFrameType>.name: String @JvmName("DataFrameType_name") get() = this["name"] as String
-```
-
-Every column produces two extension properties:
-
-* Property for `ColumnsContainer<DataFrameType>` returns column
-* Property for `DataRow<DataFrameType>` returns cell value
-
-4. `df` variable is typed by schema interface:
-
-```kotlin
-val temp = df
-```
-
-```kotlin
-val df = temp.cast<DataFrameType>()
-```
-
-> _Note, that object instance after casting remains the same. See [cast](cast.md).
-
-To log all these additional code executions, use cell magic
-
-```
-%trackExecution -all
-```

From 2e1483855b2033a374f33a4f9dec2ed09655f241 Mon Sep 17 00:00:00 2001
From: "andrei.kislitsyn" <kisandy@yandex.ru>
Date: Wed, 23 Jul 2025 15:08:29 +0400
Subject: [PATCH 3/5] data schemas docs fixes

---
 docs/StardustDocs/topics/schemas/schemas.md | 11 +++++++----
 1 file changed, 7 insertions(+), 4 deletions(-)

diff --git a/docs/StardustDocs/topics/schemas/schemas.md b/docs/StardustDocs/topics/schemas/schemas.md
index 0bed1977b0..ad98854f0c 100644
--- a/docs/StardustDocs/topics/schemas/schemas.md
+++ b/docs/StardustDocs/topics/schemas/schemas.md
@@ -84,11 +84,14 @@ df.filter { age >= 18 }
 See [](extensionPropertiesApi.md) for more information.
 
 
-## Schemas retrieving
+## Schema Retrieving
 
-Defining a data schema manually can be difficult, especially for dataframes with many columns or deeply nested structures, and may lead to mistakes in column names or types. Kotlin DataFrame provides several methods for generating data schemas.
+Defining a data schema manually can be difficult, especially for dataframes with many columns or deeply nested 
+structures, and may lead to mistakes in column names or types. 
+Kotlin DataFrame provides several methods for generating data schemas.
 
-* [**`generate..()` methods**](DataSchemaGenerationMethods.md) are extensions for [`DataFrame`](DataFrame.md) that generate a code string representing its `DataSchema`.
+* [**`generate..()` methods**](DataSchemaGenerationMethods.md) are extensions for [`DataFrame`](DataFrame.md) 
+(or for its [`schema`](schema.md)) that generate a code string representing its `DataSchema`.
 
 * [**Kotlin DataFrame Compiler Plugin**](Compiler-Plugin.md) **cannot automatically infer** a 
 data schema from external sources such as files or URLs.
@@ -116,7 +119,7 @@ It will also **automatically update** the schema during operations that modify t
 [Kotlin Symbol Processing](https://kotlinlang.org/docs/ksp-overview.html) by specifying 
 a source file path in your code file.
 
-## Extension properties generation
+## Extension Properties Generation
 
 Once you have a data schema, you can generate [extension properties](extensionPropertiesApi.md).
 

From 87d5c958c57fa5202aa14dcc01bf1afde3775411 Mon Sep 17 00:00:00 2001
From: "andrei.kislitsyn" <kisandy@yandex.ru>
Date: Wed, 23 Jul 2025 15:39:02 +0400
Subject: [PATCH 4/5] data schemas plugins changes

---
 docs/StardustDocs/topics/FAQ.md               |  5 +++--
 .../topics/schemas/Migration-From-Plugins.md  | 19 ++++++++++++++-----
 docs/StardustDocs/topics/schemas/schemas.md   |  7 +++++--
 3 files changed, 22 insertions(+), 9 deletions(-)

diff --git a/docs/StardustDocs/topics/FAQ.md b/docs/StardustDocs/topics/FAQ.md
index 852232c35f..99ed9ec049 100644
--- a/docs/StardustDocs/topics/FAQ.md
+++ b/docs/StardustDocs/topics/FAQ.md
@@ -174,8 +174,9 @@ and examples with beautiful [Kandy](https://kotlin.github.io/kandy) geo visualiz
 
 > The current Gradle plugin is **under consideration for deprecation** and may be officially marked as deprecated 
 > in future releases.
-> 
-> The KSP plugin is **not compatible with Kotlin 2.1 or newer**.
+>
+> The KSP plugin is **not compatible with [KSP2](https://github.com/google/ksp?tab=readme-ov-file#ksp2-is-here)**
+> and may **not work properly with Kotlin 2.1 or newer**.
 >
 > At the moment, **[data schema generation is handled via dedicated methods](DataSchemaGenerationMethods.md)** instead 
 > of relying on the plugins. 
diff --git a/docs/StardustDocs/topics/schemas/Migration-From-Plugins.md b/docs/StardustDocs/topics/schemas/Migration-From-Plugins.md
index fbc977a706..3349b204cd 100644
--- a/docs/StardustDocs/topics/schemas/Migration-From-Plugins.md
+++ b/docs/StardustDocs/topics/schemas/Migration-From-Plugins.md
@@ -24,7 +24,7 @@ However, they are now being phased out. This section provides an overview of the
 > However, it is planned for deprecation, and **we do not recommend using it going forward**.  
 > {style="warning"}
 
-If you still choose to use it, make sure to disable the automatic KSP dependency 
+If you still choose to use Gradle plugin, make sure to disable the automatic KSP plugin dependency 
 to avoid compatibility issues with Kotlin 2.1+ by adding this line to `gradle.properties`:
 
 ```properties
@@ -33,12 +33,21 @@ kotlin.dataframe.add.ksp=false
 
 ## KSP Plugin
 
-> The KSP plugin is **not compatible with Kotlin 2.1 or newer**.  
-> It is planned for deprecation or major changes, and **we do not recommend using it at this time**.  
-> {style="warning"}
-
 - **Generation of [data schemas](schemas.md)** from data sources  
   (files, databases, or external URLs).
     - You could copy already generated schemas from `build/generate/ksp` into your project sources.
     - To generate a `DataSchema` for a [`DataFrame`](DataFrame.md) now, use the  
       [`generate..()` methods](DataSchemaGenerationMethods.md) instead.
+
+> The KSP plugin is **not compatible with [KSP2](https://github.com/google/ksp?tab=readme-ov-file#ksp2-is-here)**
+> and may **not work properly with Kotlin 2.1 or newer**.  
+> It is planned for deprecation or major changes, and **we do not recommend using it at this time**.  
+> {style="warning"}
+
+If you still choose to use the KSP plugin with Kotlin 2.1+, 
+disable [KSP2](https://github.com/google/ksp?tab=readme-ov-file#ksp2-is-here) 
+by adding this line to `gradle.properties`:
+
+```properties
+ksp.useKSP2=false
+```
diff --git a/docs/StardustDocs/topics/schemas/schemas.md b/docs/StardustDocs/topics/schemas/schemas.md
index ad98854f0c..b4727809d5 100644
--- a/docs/StardustDocs/topics/schemas/schemas.md
+++ b/docs/StardustDocs/topics/schemas/schemas.md
@@ -107,8 +107,11 @@ It will also **automatically update** the schema during operations that modify t
 
 ### Plugins
 
-> The current Gradle plugin is **under consideration for deprecation** and may be officially marked as deprecated in future releases.  
-> The KSP plugin is currently non-functional.
+> The current Gradle plugin is **under consideration for deprecation** and 
+> may be officially marked as deprecated in future releases.
+> 
+> The KSP plugin is **not compatible with [KSP2](https://github.com/google/ksp?tab=readme-ov-file#ksp2-is-here)**
+> and may **not work properly with Kotlin 2.1 or newer**.
 >
 > At the moment, **[data schema generation is handled via dedicated methods](DataSchemaGenerationMethods.md)** instead of relying on the plugins.  
 {style="warning"}

From fff408babb6c799cce6a7fb9d1b7796a9b3f895b Mon Sep 17 00:00:00 2001
From: "andrei.kislitsyn" <kisandy@yandex.ru>
Date: Thu, 24 Jul 2025 16:13:31 +0400
Subject: [PATCH 5/5] data schemas merge fixes

---
 .../topics/schemas/DataSchemaGenerationMethods.md          | 4 ++--
 docs/StardustDocs/topics/schemas/schemas.md                | 7 ++++---
 2 files changed, 6 insertions(+), 5 deletions(-)

diff --git a/docs/StardustDocs/topics/schemas/DataSchemaGenerationMethods.md b/docs/StardustDocs/topics/schemas/DataSchemaGenerationMethods.md
index e36f233b7d..7c3755954b 100644
--- a/docs/StardustDocs/topics/schemas/DataSchemaGenerationMethods.md
+++ b/docs/StardustDocs/topics/schemas/DataSchemaGenerationMethods.md
@@ -47,7 +47,7 @@ Useful when you want to:
 * `extensionProperties`: `Boolean` – Whether to generate [extension properties](extensionPropertiesApi.md)
   in addition to `interface` declarations.  
   Useful if you don't use the [compiler plugin](Compiler-Plugin.md), otherwise they are not needed;
-  the [compiler plugin](Compiler-Plugin.md), [notebooks](schemasJupyter.md),
+  the [compiler plugin](Compiler-Plugin.md), [notebooks](gettingStartedKotlinNotebook.md),
   and older [Gradle/KSP plugin](schemasGradle.md) generate them automatically.
   Default: `false`.
 * `visibility`: `MarkerVisibility` – Visibility modifier for the generated declarations.  
@@ -122,7 +122,7 @@ in cases where the schema cannot be inferred automatically from the source.
 * `extensionProperties`: `Boolean` – Whether to generate [extension properties](extensionPropertiesApi.md)
   in addition to `interface` declarations.  
   Useful if you don't use the [compiler plugin](Compiler-Plugin.md), otherwise they are not needed;
-  the [compiler plugin](Compiler-Plugin.md), [notebooks](schemasJupyter.md),
+  the [compiler plugin](Compiler-Plugin.md), [notebooks](gettingStartedKotlinNotebook.md),
   and older [Gradle/KSP plugin](schemasGradle.md) generate them automatically.
   Default: `false`.
 * `visibility`: `MarkerVisibility` – Visibility modifier for the generated declarations.  
diff --git a/docs/StardustDocs/topics/schemas/schemas.md b/docs/StardustDocs/topics/schemas/schemas.md
index b4727809d5..09981123f5 100644
--- a/docs/StardustDocs/topics/schemas/schemas.md
+++ b/docs/StardustDocs/topics/schemas/schemas.md
@@ -141,6 +141,7 @@ See [extension properties example in Kotlin Notebook](extensionPropertiesApi.md#
 
 > Compiler Plugin is coming to Kotlin Notebook soon.
 
-* If you're not using the Compiler Plugin, you can still generate extension properties for a [`DataFrame`](DataFrame.md)
-  using the [`generateCode`](DataSchemaGenerationMethods.md#generate-code) method.
-
+* If you're not using the Compiler Plugin, you can still generate 
+[extension properties](extensionPropertiesApi.md) for a [`DataFrame`](DataFrame.md)
+manually by calling one of the [`generate..()` methods](DataSchemaGenerationMethods.md) 
+with the `extensionProperties = true` argument.