Fixed missed articles

Author: zaleslaw

README.md

@@ -101,8 +101,8 @@ This table shows the mapping between main library components versions and minimu
 
 | Kotlin DataFrame Version | Minimum Java Version | Kotlin Version | Kotlin Jupyter Version | OpenAPI version | Apache Arrow version |
 |--------------------------|----------------------|----------------|------------------------|-----------------|----------------------|
-| 0.10.0                   | 8                    |1.8.20          | 0.11.0-358             |2.1.13           | 11.0.0               |
-| 0.10.1                   | 8                    |1.8.20          | 0.11.0-358             |2.1.13           | 11.0.0               |
+| 0.10.0                   | 8                    |1.8.20          | 0.11.0-358             | 3.0.0           | 11.0.0               |
+| 0.10.1                   | 8                    |1.8.20          | 0.11.0-358             | 3.0.0           | 11.0.0               |
 
 ## Usage example
 

docs/StardustDocs/topics/schemas.md

@@ -3,21 +3,22 @@
 <!---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
+a 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.
+It ignores the 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 the 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
+## Popular use cases for Data Schemas
 
-Here's a list of the most popular use cases with Data Schemas.
+Here's a list of the most popular use cases for Data Schemas.
 
 * [**Data Schemas in Gradle projects**](schemasGradle.md) <br/>
   If you are developing a server application and building it with Gradle.
@@ -29,15 +30,15 @@ Here's a list of the most popular use cases with Data Schemas.
   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.
+  Sometimes it is necessary to create your own schema.
 
-* [**Use external Data Schemas in Jupyter**](schemasExternalJupyter.md) <br/>
+* [**Use external Data Schemas in Jupyter Notebook**](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 interfaces should also be extracted if this code uses custom Data Schemas.
 
-* [**Import OpenAPI Schemas in Gradle project**](schemasImportOpenApiGradle.md) <br/>
-  When you need to take data from the endpoint with OpenAPI Schema.
+* [**Import OpenAPI Schemas in a Gradle project**](schemasImportOpenApiGradle.md) <br/>
+  When you are using a JSON API that provides an OpenAPI schema.
 
-* [**Import Data Schemas, e.g. from OpenAPI, in Jupyter**](schemasImportOpenApiJupyter.md) <br/>
+* [**Import Data Schemas, e.g., from OpenAPI, in Jupyter**](schemasImportOpenApiJupyter.md) <br/>
   Similar to [importing OpenAPI Data Schemas in Gradle projects](schemasImportOpenApiGradle.md), 
   you can also do this in Jupyter Notebooks.

docs/StardustDocs/topics/schemasCustom.md

@@ -3,7 +3,7 @@
 <!---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:
+a specific set of columns:
 
 ```kotlin
 @DataSchema
@@ -34,7 +34,7 @@ val df = dataFrameOf("name", "age", "weight")(
 
 <!---END-->
 
-Schema of `df` is compatible with `Person`, so auto-generated schema interface will inherit from it:
+Schema of `df` is compatible with `Person`, so the auto-generated schema interface will inherit from it:
 
 ```kotlin
 @DataSchema(isOpen = false)

docs/StardustDocs/topics/schemasExternalJupyter.md

@@ -5,7 +5,7 @@
 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
+In order to enable to 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:
 

docs/StardustDocs/topics/schemasGradle.md

@@ -10,7 +10,8 @@ In Gradle projects, the Kotlin DataFrame library provides
 
 ### Configuration
 
-To use the [extension properties API](extensionPropertiesApi.md) in Gradle project add the `dataframe` plugin as follows:
+To use the [extension properties API](extensionPropertiesApi.md) in a Gradle project,
+add the `dataframe` plugin as follows:
 
 <tabs>
 <tab title="Kotlin DSL">
@@ -58,7 +59,7 @@ interface Person {
 }
 ```
 
-#### Execute assemble task to generate type-safe accessors for schemas:
+#### Execute an `assemble` task to generate type-safe accessors for schemas:
 
 <!---FUN useProperties-->
 
@@ -76,7 +77,7 @@ teens.print()
 
 ### Schema inference
 
-Specify schema with preferred method and execute the `assemble` task.
+Specify the schema with preferred method and execute the `assemble` task.
 
 <tabs>
 <tab title="Method 1. Annotation processing">
@@ -85,7 +86,7 @@ Specify schema with preferred method and execute the `assemble` task.
 You can import schemas from a URL or from the relative path of a file.
 Relative path by default is resolved to the project root directory.
 You can configure it by [passing](https://kotlinlang.org/docs/ksp-quickstart.html#pass-options-to-processors) `dataframe.resolutionDir`
-option to preprocessor.
+an option to preprocessor.
 For example:
 
 ```kotlin
@@ -98,7 +99,7 @@ ksp {
 from the previous invocation, at least one character.**
 
 For the following configuration, file `Repository.Generated.kt` will be generated to `build/generated/ksp/` folder in
-the same package as file containing the annotation.
+the same package as the file containing the annotation.
 
 ```kotlin
 @file:ImportDataSchema(
@@ -206,4 +207,4 @@ You can also always ctrl+click on the `PetStore.Pet` type to see all the generat
 If you experience any issues with the OpenAPI support (since there are many gotchas and edge-cases when converting
 something as
 type-fluid as JSON to a strongly typed language), please open an issue on
-the [Github repo](https://github.com/Kotlin/dataframe/issues).
+the [GitHub repo](https://github.com/Kotlin/dataframe/issues).

docs/StardustDocs/topics/schemasImportOpenApiGradle.md

@@ -61,4 +61,4 @@ You can also always ctrl+click on the `PetStore.Pet` type to see all the generat
 If you experience any issues with the OpenAPI support (since there are many gotchas and edge-cases when converting
 something as
 type-fluid as JSON to a strongly typed language), please open an issue on
-the [Github repo](https://github.com/Kotlin/dataframe/issues).
+the [GitHub repo](https://github.com/Kotlin/dataframe/issues).

docs/StardustDocs/topics/schemasImportOpenApiJupyter.md

@@ -13,7 +13,7 @@ Import the schema using any path (`String`), `URL`, or `File`:
 val PetStore = importDataSchema("https://petstore3.swagger.io/api/v3/openapi.json")
 ```
 
-and then from next cell you run and onwards, you can call, for example:
+and then from the next cell you run and onwards, you can call, for example:
 
 ```kotlin
 val df = PetStore.Pet.readJson("https://petstore3.swagger.io/api/v3/pet/findByStatus?status=available")

docs/StardustDocs/topics/schemasInheritance.md

@@ -2,23 +2,24 @@
 
 <!---IMPORT org.jetbrains.kotlinx.dataframe.samples.api.Schemas-->
 
-In order to reduce amount of generated code, previously generated [`DataSchema`](schema.md) interfaces are reused and only new
+In order to reduce the amount of generated code,
+previously generated [`DataSchema`](schema.md) interfaces are reused and only new
 properties are introduced
 
-Let's filter out all `null` values from `age` column and add one more column of type `Boolean`:
+Let's filter out all `null` values from `age` column and add one more column of a type `Boolean`:
 
 ```kotlin
 val filtered = df.filter { age != null }.add("isAdult") { age!! > 18 }
 ```
 
-New schema interface for `filtered` variable will be derived from previously generated `DataFrameType`:
+The new schema interface for `filtered` variable will be derived from previously generated `DataFrameType`:
 
 ```kotlin
 @DataSchema
 interface DataFrameType1 : DataFrameType
 ```
 
-Extension properties for data access are generated only for new and overriden members of `DataFrameType1` interface:
+Extension properties for data access are generated only for new and override members of `DataFrameType1` interface:
 
 ```kotlin
 val ColumnsContainer<DataFrameType1>.age: DataColumn<Int> get() = this["age"] as DataColumn<Int>
@@ -27,7 +28,7 @@ val ColumnsContainer<DataFrameType1>.isAdult: DataColumn<Boolean> get() = this["
 val DataRow<DataFrameType1>.isAdult: String get() = this["isAdult"] as Boolean
 ```
 
-Then variable `filtered` is cast to new interface:
+Then variable `filtered` is cast to the new interface:
 
 ```kotlin
 val temp = filtered

docs/StardustDocs/topics/schemasJupyter.md

@@ -49,7 +49,7 @@ val temp = df
 val df = temp.cast<DataFrameType>()
 ```
 
-> _Note, that object instance after casting remains the same. See [cast](cast.md).
+> _Note that object instance after casting remains the same. See [cast](cast.md).
 
 To log all these additional code executions, use cell magic